commit facbde984e4da358c62f24b82dd31a6bceac04ac Author: Demetrius Kanios Date: Wed Sep 16 21:31:34 2026 -0700 Initial setup diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..a381fc4 --- /dev/null +++ b/.gitignore @@ -0,0 +1,17 @@ +.dub +docs.json +__dummy.html +docs/ +/pumpkin-api-d +pumpkin-api-d.so +pumpkin-api-d.dylib +pumpkin-api-d.dll +libpumpkin-api-d.a +pumpkin-api-d.a +pumpkin-api-d.lib +pumpkin-api-d-test-* +*.exe +*.pdb +*.o +*.obj +*.lst diff --git a/dub.json b/dub.json new file mode 100644 index 0000000..5c34a9f --- /dev/null +++ b/dub.json @@ -0,0 +1,13 @@ +{ + "description": "D bindings to PumpkinMC's plugin API.", + "license": "MIT OR Apache-2.0", + "authors": ["Demetrius Kanios"], + "copyright": "Copyright © 2026, Demetrius Kanios", + "name": "pumpkin-api-d", + "targetType": "staticLibrary", + "toolchainRequirements": { + "dmd": "no", + "gdc": "no", + "ldc": ">=1.43.0" + } +} diff --git a/dub.selections.json b/dub.selections.json new file mode 100644 index 0000000..031e5a9 --- /dev/null +++ b/dub.selections.json @@ -0,0 +1,5 @@ +{ + "fileVersion": 1, + "versions": { + } +} \ No newline at end of file diff --git a/src/pumpkin/register.d b/src/pumpkin/register.d new file mode 100644 index 0000000..597e9dd --- /dev/null +++ b/src/pumpkin/register.d @@ -0,0 +1,514 @@ +module pumpkin.register; + +import wit.pumpkin.plugin.plugin; +import wit.common; + +import std.meta : AliasSeq, staticIndexOf; +import std.traits : isFunction, getUDAs, EnumMembers; + +struct GetMetadata; +struct OnLoad; +struct OnUnload; +struct HandleIpcMessage; + +struct NoAutoRegister; + +struct EventHandler { + EventType type; + EventPriority priority = EventPriority.normal; + bool blocking = true; +} + +struct CommandHandler; +struct TaskHandler; +struct SuggestionHandler; +struct AIGoal(Plugin); +struct ChunkGenerator(Plugin); + +template PluginInfo(P) { + alias members = __traits(allMembers, P); + + alias getMetadatas = AliasSeq!(); + alias onLoads = AliasSeq!(); + alias onUnloads = AliasSeq!(); + alias ipcHandlers = AliasSeq!(); + alias eventHandlers = AliasSeq!(); + + static foreach (memberName; members) { + static foreach (member; __traits(getOverloads, P, memberName)) { + static foreach (uda; __traits(getAttributes, member)) { + static if (is(uda == GetMetadata) || is(typeof(uda) == GetMetadata)) { + getMetadatas = AliasSeq!(member); + } else static if (is(uda == OnLoad) || is(typeof(uda) == OnLoad)) { + onLoads = AliasSeq!(member); + } else static if (is(uda == OnUnload) || is(typeof(uda) == OnUnload)) { + onUnloads = AliasSeq!(member); + } else static if (is(uda == HandleIpcMessage) || is(typeof(uda) == HandleIpcMessage)) { + ipcHandlers = AliasSeq!(member); + } else static if (is(uda == EventHandler) || is(typeof(uda) == EventHandler)) { + eventHandlers = AliasSeq!(eventHandlers, member); + } + } + } + } + + static assert(getMetadatas.length == 1, "Exactly one method must be marked `@GetMetadata` in plugin `", __traits( + fullyQualifiedName, symbol), "`"); + static assert(onLoads.length <= 1, "At most one method can be marked `@OnLoad` in plugin `", __traits( + fullyQualifiedName, symbol), "`"); + static assert(onUnloads.length <= 1, "At most one method can be marked `@OnUnload` in plugin `", __traits( + fullyQualifiedName, symbol), "`"); + static assert(ipcHandlers.length <= 1, "At most one method can be marked `@HandleIpcMessage` in plugin `", __traits( + fullyQualifiedName, symbol), "`"); +} + +/// A fatal error has occurred. Log an error and trap. +noreturn bail(in char[] msg) +{ + import core.stdc.stdlib : abort; + + log(Level.error, msg.witList); + abort(); +} + +private template eventHandlerShim(alias symbol) + if (isFunction!symbol && !__traits(isStaticFunction, symbol)) { + alias udas = getUDAs!(symbol, EventHandler); + static assert(udas.length == 1, + "Handler must be marked with exactly one `@EventHandler`"); + + static assert(is(typeof(udas[0]) == EventHandler), + "`@EventHandler` must be given parameters. `@EventHandler(...)`, not plain `@EventHandler`"); + + static if (udas.length) { + alias Sig = void function(Server, scope ref Event.Types[udas[0].type]); + static assert(is(typeof(&symbol) : Sig), "The event handler `", __traits(fullyQualifiedName, symbol), "` ", + "must conform to the necessary signature. ", "Found `", + typeof(&symbol), "`", ", but expected `", Sig, "`"); + } + + alias P = __traits(parent, symbol); + void shim(ref P plugin, Server server, scope ref Event e) + { + enum tag = EnumMembers!(Event.Tag)[udas[0].type]; + __traits(child, plugin, symbol)(server, e._get!tag); + } + + enum eventHandlerShim = &shim; +} + +private template commandHandlerShim(alias symbol) + if (isFunction!symbol && !__traits(isStaticFunction, symbol)) { + alias udas = getUDAs!(symbol, CommandHandler); + static assert(udas.length == 1, + "Handler must be marked with exactly one `@CommandHandler`"); + + alias Sig = Result!(int, CommandError) function(CommandSender, Server, ConsumedArgs); + static assert(is(typeof(&symbol) : Sig), "The command handler `", __traits(fullyQualifiedName, symbol), "` ", + "must conform to the necessary signature. ", "Found `", + typeof(&symbol), "`", ", but expected `", Sig, "`"); + + alias P = __traits(parent, symbol); + Result!(int, CommandError) shim(ref P plugin, CommandSender sender, Server server, ConsumedArgs args) + { + return __traits(child, plugin, symbol)(sender, server, args); + } + + enum commandHandlerShim = &shim; +} + +private template suggestionHandlerShim(alias symbol) + if (isFunction!symbol && !__traits(isStaticFunction, symbol)) { + alias udas = getUDAs!(symbol, SuggestionHandler); + static assert(udas.length == 1, + "Handler must be marked with exactly one `@SuggestionHandler`"); + + alias Sig = CommandSuggestions function(CommandSender, Server, in SuggestionRequest); + static assert(is(typeof(&symbol) : Sig), "Suggestion handler signature mismatch for `", __traits( + fullyQualifiedName, symbol), "`"); + + alias P = __traits(parent, symbol); + CommandSuggestions shim(ref P plugin, CommandSender sender, Server server, in SuggestionRequest request) + { + return __traits(child, plugin, symbol)(sender, server, request); + } + + enum suggestionHandlerShim = &shim; +} + +private template taskHandlerShim(alias symbol) + if (isFunction!symbol && !__traits(isStaticFunction, symbol)) { + alias udas = getUDAs!(symbol, TaskHandler); + static assert(udas.length == 1, + "Handler must be marked with exactly one `@TaskHandler`"); + + alias Sig = void function(Server); + static assert(is(typeof(&symbol) : Sig), "The task handler `", __traits(fullyQualifiedName, symbol), "` ", + "must conform to the necessary signature. ", "Found `", + typeof(&symbol), "`", ", but expected `", Sig, "`"); + + alias P = __traits(parent, symbol); + void shim(ref P plugin, Server server) + { + __traits(child, plugin, symbol)(server); + } + + enum taskHandlerShim = &shim; +} + +struct AIGoalShimTable(P) { + bool function(ref P, Server, Entity) canStart; + bool function(ref P, Server, Entity) shouldContinue; + void function(ref P, Server, Entity) start; + void function(ref P, Server, Entity) tick; + void function(ref P, Server, Entity) stop; +} + +private template pluginForAIGoal(Goal) { + alias udas = getUDAs!(Goal, AIGoal); + static assert(udas.length == 1, "AI goal `", __traits(fullyQualifiedName, Goal), "` must be marked with exactly one `@AIGoal!PluginType`"); + + static if (udas.length) { + static if (is(udas[0] == AIGoal!P, P)) { + alias pluginForAIGoal = P; + } + } +} + +private template aiGoalShim(Goal) { + alias P = pluginForAIGoal!Goal; + + static assert(__traits(hasMember, Goal, "canStart"), "AI goal `", __traits( + fullyQualifiedName, Goal), "` needs a static method named `canStart`"); + static assert(__traits(hasMember, Goal, "shouldContinue"), "AI goal `", __traits( + fullyQualifiedName, Goal), "` needs a static method named `shouldContinue`"); + static assert(__traits(hasMember, Goal, "start"), "AI goal `", __traits( + fullyQualifiedName, Goal), "` needs a static method named `start`"); + static assert(__traits(hasMember, Goal, "tick"), "AI goal `", __traits( + fullyQualifiedName, Goal), "` needs a static method named `tick`"); + static assert(__traits(hasMember, Goal, "stop"), "AI goal `", __traits( + fullyQualifiedName, Goal), "` needs a static method named `stop`"); + + static assert(__traits(isStaticFunction, Goal.canStart), "`" ~ __traits( + fullyQualifiedName, Goal.canStart) ~ "` must be static (AI goals must be stateless)"); + static assert(__traits(isStaticFunction, Goal.shouldContinue), "`" ~ __traits( + fullyQualifiedName, Goal.shouldContinue) ~ "` must be static (AI goals must be stateless)"); + static assert(__traits(isStaticFunction, Goal.start), "`" ~ __traits( + fullyQualifiedName, Goal.start) ~ "` must be static (AI goals must be stateless)"); + static assert(__traits(isStaticFunction, Goal.tick), "`" ~ __traits( + fullyQualifiedName, Goal.tick) ~ "` must be static (AI goals must be stateless)"); + static assert(__traits(isStaticFunction, Goal.stop), "`" ~ __traits( + fullyQualifiedName, Goal.stop) ~ "` must be static (AI goals must be stateless)"); + + alias BoolSig = bool function(ref P, Server, Entity); + alias VoidSig = void function(ref P, Server, Entity); + + static assert(is(typeof(&Goal.canStart) : BoolSig), "The AI goal method `", __traits(fullyQualifiedName, Goal + .canStart), "` ", + "must conform to the necessary signature. ", "Found `", + typeof(&Goal.canStart), "`", ", but expected `", BoolSig, "`"); + static assert(is(typeof(&Goal.shouldContinue) : BoolSig), "The AI goal method `", __traits(fullyQualifiedName, Goal + .shouldContinue), "` ", + "must conform to the necessary signature. ", "Found `", + typeof(&Goal.shouldContinue), "`", ", but expected `", BoolSig, "`"); + static assert(is(typeof(&Goal.start) : VoidSig), "The AI goal method `", __traits(fullyQualifiedName, Goal + .start), "` ", + "must conform to the necessary signature. ", "Found `", + typeof(&Goal.start), "`", ", but expected `", VoidSig, "`"); + static assert(is(typeof(&Goal.tick) : VoidSig), "The AI goal method `", __traits(fullyQualifiedName, Goal + .tick), "` ", + "must conform to the necessary signature. ", "Found `", + typeof(&Goal.tick), "`", ", but expected `", VoidSig, "`"); + static assert(is(typeof(&Goal.stop) : VoidSig), "The AI goal method `", __traits(fullyQualifiedName, Goal + .stop), "` ", + "must conform to the necessary signature. ", "Found `", + typeof(&Goal.stop), "`", ", but expected `", VoidSig, "`"); + + bool shimCanStart(ref P plugin, Server server, Entity entity) => Goal.canStart(plugin, server, entity); + bool shimShouldContinue(ref P plugin, Server server, Entity entity) => Goal.shouldContinue(plugin, server, entity); + void shimStart(ref P plugin, Server server, Entity entity) => Goal.start(plugin, server, entity); + void shimTick(ref P plugin, Server server, Entity entity) => Goal.tick(plugin, server, entity); + void shimStop(ref P plugin, Server server, Entity entity) => Goal.stop(plugin, server, entity); + + __gshared immutable AIGoalShimTable!P shim = AIGoalShimTable!P( + &shimCanStart, + &shimShouldContinue, + &shimStart, + &shimTick, + &shimStop + ); + + enum aiGoalShim = &shim; +} + +struct ChunkGeneratorShimTable(P) { + void function(ref P, ChunkBuffer) biomes; + void function(ref P, ChunkBuffer) noise; + void function(ref P, ChunkBuffer) surface; + void function(ref P, ChunkBuffer) features; +} + +private template pluginForChunkGenerator(Generator) { + alias udas = getUDAs!(Generator, ChunkGenerator); + static assert(udas.length == 1, "Chunk generator `", __traits(fullyQualifiedName, Goal), "` must be marked with exactly one `@ChunkGenerator!PluginType`"); + + static if (udas.length) { + static if (is(udas[0] == ChunkGenerator!P, P)) { + alias pluginForChunkGenerator = P; + } + } +} + +private template chunkGeneratorShim(Generator) { + alias P = pluginForChunkGenerator!Generator; + + static assert(__traits(hasMember, Generator, "biomes"), "Chunk generator `", __traits( + fullyQualifiedName, Generator), "` needs a static method named `biomes`"); + static assert(__traits(hasMember, Generator, "noise"), "Chunk generator `", __traits( + fullyQualifiedName, Generator), "` needs a static method named `noise`"); + static assert(__traits(hasMember, Generator, "surface"), "Chunk generator `", __traits( + fullyQualifiedName, Generator), "` needs a static method named `surface`"); + static assert(__traits(hasMember, Generator, "features"), "Chunk generator `", __traits( + fullyQualifiedName, Generator), "` needs a static method named `features`"); + + static assert(__traits(isStaticFunction, Generator.biomes), "`" ~ __traits( + fullyQualifiedName, Generator.biomes) ~ "` must be static"); + static assert(__traits(isStaticFunction, Generator.noise), "`" ~ __traits( + fullyQualifiedName, Generator.noise) ~ "` must be static"); + static assert(__traits(isStaticFunction, Generator.surface), "`" ~ __traits( + fullyQualifiedName, Generator.surface) ~ "` must be static"); + static assert(__traits(isStaticFunction, Generator.features), "`" ~ __traits( + fullyQualifiedName, Generator.features) ~ "` must be static"); + + alias Sig = void function(ref P, ChunkBuffer); + + static assert(is(typeof(&Generator.biomes) : Sig), "The chunk generator method `", __traits(fullyQualifiedName, Generator + .biomes), "` ", + "must conform to the necessary signature. ", "Found `", + typeof(&Generator.biomes), "`", ", but expected `", Sig, "`"); + static assert(is(typeof(&Generator.noise) : Sig), "The chunk generator method `", __traits(fullyQualifiedName, Generator + .noise), "` ", + "must conform to the necessary signature. ", "Found `", + typeof(&Generator.noise), "`", ", but expected `", Sig, "`"); + static assert(is(typeof(&Generator.surface) : Sig), "The chunk generator method `", __traits(fullyQualifiedName, Generator + .surface), "` ", + "must conform to the necessary signature. ", "Found `", + typeof(&Generator.surface), "`", ", but expected `", Sig, "`"); + static assert(is(typeof(&Generator.features) : Sig), "The chunk generator method `", __traits(fullyQualifiedName, Generator + .features), "` ", + "must conform to the necessary signature. ", "Found `", + typeof(&Generator.features), "`", ", but expected `", Sig, "`"); + + void shimBiomes(ref P plugin, ChunkBuffer buffer) => Generator.biomes(plugin, buffer); + void shimNoise(ref P plugin, ChunkBuffer buffer) => Generator.noise(plugin, buffer); + void shimSurface(ref P plugin, ChunkBuffer buffer) => Generator.surface(plugin, buffer); + void shimFeatures(ref P plugin, ChunkBuffer buffer) => Generator.features(plugin, buffer); + + __gshared immutable ChunkGeneratorShimTable!P shim = ChunkGeneratorShimTable!P( + &shimBiomes, + &shimNoise, + &shimSurface, + &shimFeatures + ); + + enum chunkGeneratorShim = &shim; +} + +void registerEventHandler(alias symbol)(Context ctx) +{ + alias udas = getUDAs!(symbol, EventHandler); + + static bool registered = false; + if (registered) { + log(Level.warn, ("Tried to register the same event handler `" ~ __traits(fullyQualifiedName, + symbol) ~ "` multiple times.").witList); + return; + } + registered = true; + + ctx.registerEvent(cast(size_t)eventHandlerShim!symbol, udas[0].type, udas[0].priority, udas[0] + .blocking); +} + +void execute(alias symbol)(Command.Borrow command) +{ + command.executeWithHandlerId(cast(size_t)commandHandlerShim!symbol); +} + +void execute(alias symbol)(CommandNode.Borrow node) +{ + node.executeWithHandlerId(cast(size_t)commandHandlerShim!symbol); +} + +void suggest(alias symbol)(CommandNode.Borrow node) +{ + node.suggestWithHandlerId(cast(size_t)suggestionHandlerShim!symbol); +} + +uint scheduleDelayed(alias symbol)(ulong delayTicks) +{ + return scheduleDelayedTask(cast(size_t)taskHandlerShim!symbol, delayTicks); +} + +uint scheduleRepeating(alias symbol)(ulong delayTicks, ulong periodTicks) +{ + return scheduleRepeatingTask(cast(size_t)taskHandlerShim!symbol, delayTicks, periodTicks); +} + +void attachCustomAiGoal(Goal)(Mob.Borrow mob, ubyte priority = 0) +{ + mob.addCustomAiGoal(priority, cast(size_t)aiGoalShim!Goal); +} + +void setCustomChunkGenerator(alias Generator)(World.Borrow world) +{ + world.setChunkGenerator(cast(size_t)chunkGeneratorShim!Generator); +} + +mixin template RegisterPlugin(P) { + __gshared P globalPluginInst; + + alias PInfo = PluginInfo!P; + + @witInterface("pumpkin:plugin/metadata@0.1.0") + @witExport PluginMetadata getMetadata() + { + return __traits(child, globalPluginInst, PInfo.getMetadatas[0])(); + } + + @witInterface("$root") { + @witExport void initPlugin() + { + version (D_BetterC) { + } else { + import core.runtime; + + Runtime.initialize(); + } + + import core.lifetime; + + emplace(&globalPluginInst); + } + + @witExport Result!(void, WitString) onLoad(Context ctx) + { + import std.traits : hasUDA; + + static foreach (alias handler; PInfo.eventHandlers) { + static if (!hasUDA!(handler, NoAutoRegister)) { + ctx.registerEventHandler!handler; + } + } + + static if (PInfo.onLoads.length == 1) { + return __traits(child, globalPluginInst, PInfo.onLoads[0])(ctx); + } else { + return ok!WitString(); + } + } + + @witExport Result!(void, WitString) onUnload(Context ctx) + { + static if (PInfo.onUnloads.length == 1) { + return __traits(child, globalPluginInst, PInfo.onUnloads[0])(ctx); + } else { + return ok!WitString(); + } + } + + @witExport Event handleEvent(uint eventId, Server server, ref scope Event event) + { + auto ret = event.witClone; + + alias EventShim = void function(ref P plugin, Server, scope ref Event); + (cast(EventShim)eventId)(globalPluginInst, server, ret); + return ret; + } + + @witExport Result!(int, CommandError) handleCommand(uint commandId, + CommandSender sender, Server server, ConsumedArgs args) + { + alias CommandShim = Result!(int, CommandError) function(ref P, CommandSender, Server, ConsumedArgs); + return (cast(CommandShim)(commandId))(globalPluginInst, sender, server, args); + } + + @witExport CommandSuggestions handleCommandSuggestion(uint suggestionId, + CommandSender sender, Server server, in SuggestionRequest request) + { + alias SuggestionShim = CommandSuggestions function(ref P, CommandSender, Server, in SuggestionRequest); + return (cast(SuggestionShim)(suggestionId))(globalPluginInst, sender, server, request); + } + + @witExport void handleTask(uint taskId, Server server) + { + alias TaskShim = void function(ref P, Server); + (cast(TaskShim)(taskId))(globalPluginInst, server); + } + + @witExport Result!(IpcMessage, WitString) handleIpcMessage(in WitString sender, + in IpcMessage message) + { + static if (PInfo.ipcHandlers.length == 1) { + return __traits(child, globalPluginInst, PInfo.ipcHandlers[0])(sender, message); + } else { + return err!IpcMessage("This plugin cannot recieve messages.".witList.witClone); + } + } + + @witExport bool handleAIGoalCanStart(uint goalId, Server server, Entity entity) + { + auto table = cast(const(AIGoalShimTable!P)*)goalId; + return table.canStart(globalPluginInst, server, entity); + } + + @witExport bool handleAIGoalShouldContinue(uint goalId, Server server, Entity entity) + { + auto table = cast(const(AIGoalShimTable!P)*)goalId; + return table.shouldContinue(globalPluginInst, server, entity); + } + + @witExport void handleAIGoalStart(uint goalId, Server server, Entity entity) + { + auto table = cast(const(AIGoalShimTable!P)*)goalId; + table.start(globalPluginInst, server, entity); + } + + @witExport void handleAIGoalTick(uint goalId, Server server, Entity entity) + { + auto table = cast(const(AIGoalShimTable!P)*)goalId; + table.tick(globalPluginInst, server, entity); + } + + @witExport void handleAIGoalStop(uint goalId, Server server, Entity entity) + { + auto table = cast(const(AIGoalShimTable!P)*)goalId; + table.stop(globalPluginInst, server, entity); + } + + @witExport void handleGeneratePhase(uint generatorId, GenerationPhase phase, ChunkBuffer buffer) + { + auto table = cast(const(ChunkGeneratorShimTable!P)*)generatorId; + + final switch (phase) { + case GenerationPhase.biomes: + table.biomes(globalPluginInst, buffer); + break; + case GenerationPhase.noise: + table.noise(globalPluginInst, buffer); + break; + case GenerationPhase.surface: + table.surface(globalPluginInst, buffer); + break; + case GenerationPhase.features: + table.features(globalPluginInst, buffer); + break; + } + } + } + + alias Exports = wit.pumpkin.plugin.plugin.Exports!(getMetadata, + initPlugin, onLoad, onUnload, handleEvent, handleCommand, + handleCommandSuggestion, handleTask, handleIpcMessage, handleAIGoalCanStart, handleAIGoalShouldContinue, + handleAIGoalStart, handleAIGoalTick, handleAIGoalStop, handleGeneratePhase); +} diff --git a/src/wit/common.d b/src/wit/common.d new file mode 100644 index 0000000..04135a9 --- /dev/null +++ b/src/wit/common.d @@ -0,0 +1,786 @@ +module wit.common; + +import core.attribute : mustuse; +import ldc.attributes : llvmAttr; + +alias wasmImport(string mod, string name) = AliasSeq!( + llvmAttr("wasm-import-module", mod), + llvmAttr("wasm-import-name", name) +); + +enum wasmExport(string name) = llvmAttr("wasm-export-name", name); + +struct witInterface { string name; } +struct witExport { string name; } + +/// Thin CABI compliant wrapper over `T[]` +struct WitList(T) { +@safe @nogc pure nothrow pragma(inline, true): + T* ptr; + size_t length; + + this(inout T[] slice) inout @trusted { + ptr = slice.ptr; + length = slice.length; + } + + void opAssign(T[] slice) @trusted { + ptr = slice.ptr; + length = slice.length; + } + + alias asSlice this; + inout(T)[] asSlice() @trusted inout { + return (ptr && length) ? ptr[0..length] : null; + } + + bool opEquals(in T[] other) const => this[] == other; + size_t toHash() const => this[].hashOf; +} +pragma(inline, true) auto witList(T)(inout T[] slice) => inout WitList!T(slice); + +// WIT ABI for string matches List, +// except list in WIT is actually List!(dchar) +// +// We assume UTF-8 data (as D native strings are UTF-8) +alias WitString = WitList!(char); + +// TODO: split this file up and give Tuple a full port of the Phobos version? +/// adapted from Phobos std.typecons.Tuple +/// No support for naming members. +struct Tuple(Types...) if (is(Types)) { + Types expand; + alias expand this; +} + +inout(Tuple!Types) tuple(Types...)(inout Types vals) => inout Tuple!Types(vals); + +mixin template WitFlags(T) if (__traits(isUnsigned, T)) { + private alias F = typeof(this); + + T bits; + + @safe nothrow @nogc pure pragma(inline, true): + + static typeof(this) opIndex(size_t i) + in(i < T.sizeof*8) => F(cast(T)(1 << i)); + + auto opUnary(string op : "~")() const => F(~bits); + + auto ref opOpAssign(string op)(F rhs) + if (op == "|" || op == "&" || op == "^") + { + mixin("bits "~op~"= rhs.bits;"); + return this; + } + + auto opBinary(string op)(F flags) const + if (op == "|" || op == "&" || op == "^") + { + F result = this; + result.opOpAssign!op(flags); + return result; + } + + typeof(this) witClone() const { return this; } +} + + +mixin template WitVariant(T...) { + public alias Types = T; + +private: + static assert(is(typeof(this).Tag)); + static assert(is(Tag U == enum) && __traits(isIntegral, U)); + + static assert(__traits(allMembers, Tag).length == Types.length); + static foreach (i, M; __traits(allMembers, Tag)) { + static assert(i == __traits(getMember, Tag, M)); + } + + union Storage { + template ReplacedTypes() { + alias ReplacedTypes = AliasSeq!(); + + static foreach (T; Types) { + static if (is(T == void)) + ReplacedTypes = AliasSeq!(ReplacedTypes, void[0]); + else + ReplacedTypes = AliasSeq!(ReplacedTypes, T); + } + } + + ubyte __zeroinit = 0; + ReplacedTypes!() members; + } + + Tag _tag; + Storage _storage; + + + @disable this(); + + pragma(inline, true) + this(Tag tag, inout Storage storage = Storage.init) inout @nogc nothrow @trusted { + _tag = tag; + _storage = storage; + } + +public: + pragma(inline, true) + static auto _create(Tag tag)() if (is(Types[tag] == void)) { + return typeof(this)(tag); + } + + pragma(inline, true) + static auto _create(Tag tag)(inout Types[tag] val) if (!is(Types[tag] == void)) { + Storage storage = Storage.init; + storage.tupleof[tag+1] = cast(Types[tag])val; + return inout typeof(this)(tag, cast(inout(Storage))storage); + } + + pragma(inline, true) + ref auto _get(Tag tag)() inout return if (!is(Types[tag] == void)) + in (_tag == tag) do { return cast(inout)_storage.tupleof[tag+1]; } +} + +/// Based on Rust's Option +struct Option(T) { +private: + bool _present = false; + T _value; + + pragma(inline, true) + this(bool present, inout T value) inout @safe @nogc nothrow { + _present = present; + _value = value; + } +public: + pragma(inline, true) + static inout(Option) makeSome(inout T value) @safe @nogc nothrow { + return inout Option(true, value); + } + + pragma(inline, true) + static Option makeNone() @safe @nogc nothrow { + return Option(false, T.init); + } + + pragma(inline, true) + bool isSome() const @safe @nogc nothrow => _present; + alias isSome this; // implicit conversion to bool + + pragma(inline, true) + bool isNone() const @safe @nogc nothrow => !_present; + + pragma(inline, true) + ref inout(T) unwrap() inout @trusted @nogc nothrow return + in (_present) do { return _value; } + + pragma(inline, true) + T unwrapOr(T fallback) @trusted @nogc nothrow => _present ? _value : fallback; + + T unwrapOrElse(D)(scope D fallback) + if (is(D R == return) && is(R : T) && is(D == __parameters)) + { return _present ? _value : fallback(); } + + bool opEquals(in Option rhs) const { + if (isSome != rhs.isSome) return false; + + if (isSome) return unwrap == rhs.unwrap; + else return true; + } + + size_t toHash() const @safe pure nothrow + { + if (isSome) return this.unwrap.hashOf(true.hashOf); + return false.hashOf; + } +} + +pragma(inline, true) +auto some(T)(inout T value) @safe @nogc nothrow { + return Option!T.makeSome(value); +} + +pragma(inline, true) +auto none(T)() @safe @nogc nothrow { + return Option!T.makeNone; +} + +/// Based on Rust's Result +@mustuse +struct Result(T = void, E = void) { +private: + bool _hasError; + union Storage { + ubyte __zeroinit = 0; + static if (!is(T == void)) { + T value; + } + static if (!is(E == void)) { + E error; + } + } + Storage _storage; + + this(bool hasError, inout(Storage) storage) inout @safe @nogc nothrow { + _hasError = hasError; + _storage = storage; + } + +public: + static if (is(T == void)) { + pragma(inline, true) + static Result makeOk() @safe @nogc nothrow => Result(false, Storage.init); + } else { + pragma(inline, true) + static inout(Result) makeOk(inout(T) value) @trusted @nogc nothrow { + Storage newStorage = Storage.init; + newStorage.value = cast(T)value; + + return inout Result(false, cast(inout Storage)newStorage); + } + } + + static if (is(E == void)) { + pragma(inline, true) + static Result makeErr() @safe @nogc nothrow => Result(true, Storage.init); + } else { + pragma(inline, true) + static inout(Result) makeErr(inout(E) error) @trusted @nogc nothrow { + Storage newStorage = Storage.init; + newStorage.error = cast(E)error; + + return inout Result(true, cast(inout Storage)newStorage); + } + } + + pragma(inline, true) + bool isOk() const @safe @nogc nothrow => !_hasError; + + pragma(inline, true) + bool isErr() const @safe @nogc nothrow => _hasError; + alias isErr this; // implicit conversion to bool + + static if (!is(T == void)) { + pragma(inline, true) + ref inout(T) unwrap() inout @trusted @nogc nothrow return + in (isOk) do { return _storage.value; } + + pragma(inline, true) + T unwrapOr(T fallback) @trusted @nogc nothrow => isOk ? _storage.value : fallback; + + T unwrapOrElse(D)(scope D fallback) + if (is(D R == return) && is(R : T) && is(D == __parameters)) + { return isOk ? _storage.value : fallback(); } + } + + static if (!is(E == void)) { + pragma(inline, true) + ref inout(E) unwrapErr() inout @trusted @nogc nothrow return + in (isErr) do { return _storage.error; } + } + + bool opEquals(in Result rhs) const { + if (isErr != rhs.isErr) return false; + + if (isErr) { + static if (!is(E == void)) return unwrapErr == rhs.unwrapErr; + else return true; + } + + static if (!is(T == void)) return unwrap == rhs.unwrap; + else return true; + } + + size_t toHash() const @safe pure nothrow + { + if (isErr) { + static if (!is(E == void)) return this.unwrapErr.hashOf(true.hashOf); + return true.hashOf; + } + + static if (!is(T == void)) return this.unwrap.hashOf(false.hashOf); + else return false.hashOf; + } +} + +pragma(inline, true) +auto ok(E, T)(inout T value) @safe @nogc nothrow { + return Result!(T, E).makeOk(value); +} +pragma(inline, true) +auto ok(E)() @safe @nogc nothrow { + return Result!(void, E).makeOk(); +} + +pragma(inline, true) +auto err(T, E)(inout E value) @safe @nogc nothrow { + return Result!(T, E).makeErr(value); +} +pragma(inline, true) +auto err(T)() @safe @nogc nothrow { + return Result!(T, void).makeErr(); +} + +pragma(inline, true) +void witFree(T)(scope ref T val) if (__traits(isArithmetic, T)) { + // no-op +} +pragma(inline, true) +void witDrop(T)(scope ref T val) if (__traits(isArithmetic, T)) { + // no-op +} +pragma(inline, true) +T witClone(T)(in T val) if (__traits(isArithmetic, T)) { + return val; +} + +pragma(inline, true) +void witFree(T : Option!U, U)(scope ref T val) { + static if (!is(U == void)) if (val.isSome) val.unwrap.witFree; +} +pragma(inline, true) +void witDrop(T : Option!U, U)(scope ref T val) { + static if (!is(U == void)) if (val.isSome) val.unwrap.witDrop; +} +pragma(inline, true) +T witClone(T : Option!U, U)(in T val) { + if (val.isSome) { + static if (!is(U == void)) { + return T.makeSome(val.unwrap.witClone); + } else { + return T.makeSome; + } + } else { + return T.makeNone; + } +} + +pragma(inline, true) +void witFree(T : Result!(U, V), U, V)(scope ref T val) { + if (val.isErr) { + static if (!is(V == void)) val.unwrapErr.witFree; + } else { + static if (!is(U == void)) val.unwrap.witFree; + } +} +pragma(inline, true) +void witDrop(T : Result!(U, V), U, V)(scope ref T val) { + if (val.isErr) { + static if (!is(V == void)) val.unwrapErr.witDrop; + } else { + static if (!is(U == void)) val.unwrap.witDrop; + } +} +pragma(inline, true) +T witClone(T : Result!(U, V), U, V)(in T val) { + if (val.isErr) { + static if (!is(V == void)) { + return T.makeErr(val.unwrapErr.witClone); + } else { + return T.makeErr; + } + } else { + static if (!is(U == void)) { + return T.makeOk(val.unwrap.witClone); + } else { + return T.makeOk; + } + } +} + +pragma(inline, true) +void witFree(T : WitList!U, U)(scope ref T val) { + foreach (ref e; val) { + e.witFree; + } + if (val.ptr && val.length) free(val.ptr); + val = null; +} +pragma(inline, true) +void witDrop(T : WitList!U, U)(scope ref T val) { + foreach (ref e; val) { + e.witDrop; + } + val = null; +} +T witClone(T : WitList!U, U)(in T val) @trusted { + if (val.ptr == null || val.length == 0) return T(null); + + auto clone = mallocSlice!U(val.length); + + foreach (i, ref e; clone) { + e = val[i].witClone; + } + + return clone.witList; +} + +pragma(inline, true) +void witFree(T : Tuple!U, U...)(scope ref T val) { + static foreach (F; T.tupleof) { + __traits(child, val, F).witFree; + } +} +pragma(inline, true) +void witDrop(T : Tuple!U, U...)(scope ref T val) { + static foreach (F; T.tupleof) { + __traits(child, val, F).witDrop; + } +} +pragma(inline, true) +T witClone(T : Tuple!U, U...)(in T val) { + T clone = void; + static foreach (F; T.tupleof) { + __traits(child, clone, F) = __traits(child, val, F).witClone; + } + return clone; +} + + +pragma(inline, true) +void witFree(T, size_t L)(scope ref T[L] val) { + foreach (ref e; val) { + e.witFree; + } +} +pragma(inline, true) +void witDrop(T, size_t L)(scope ref T[L] val) { + foreach (ref e; val) { + e.witDrop; + } +} +pragma(inline, true) +T[L] witClone(T, size_t L)(in T[L] val) { + T[L] clone; + foreach (i, ref e; clone) { + e = val[i].witClone; + } + return clone; +} + +package: + +extern(C) @nogc nothrow { + void* malloc(size_t size); + void* realloc(void* ptr, size_t newSize); + void free(void* ptr); + noreturn abort(); +} + +// from https://github.com/Inochi2D/numem/blob/main/source/numem/casting.d +// Copyright © 2023-2025, Kitsunebi Games +// Copyright © 2023-2025, Inochi2D Project +// License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0) +// Authors: Luna Nielsen +pragma(inline, true) +auto ref T reinterpretCast(T, U)(auto ref U from) @trusted if (T.sizeof == U.sizeof) { + union tmp { U from; T to; } + return tmp(from).to; +} + +pragma(inline, true) +T[] mallocSlice(T)(size_t count) @nogc nothrow { + if (count == 0) return []; + auto ptr = malloc(count*T.sizeof); + if (ptr is null) return []; + + return (cast(T*)ptr)[0..count]; +} + +// from std.meta +alias AliasSeq(T...) = T; + +template witInterfaceOf(alias Symbol) { + alias udas = AliasSeq!(); + static foreach (uda; __traits(getAttributes, Symbol)) { + static if (!is(uda) && is(typeof(uda) == witInterface)) { + udas = AliasSeq!(udas, uda); + } + } + + static assert( + udas.length <= 1, + "There must be at most one `@witInterface` attached. Found multiple on `", + __traits(fullyQualifiedName, Symbol), "`.", + ); + + static if (udas.length) { + enum string witInterfaceOf = udas[0].name; + } else { + enum string witInterfaceOf = ""; + } +} + +alias toKebabCase = (string s) { // lambda to satisfy `betterC` (use of GC) + if (s.length == 0) return ""; + + char[] buf; + foreach (i, c; s) { + if (i > 0 && c >= 'A' && c <= 'Z') { + char prev = s[i - 1]; + char next = ((i + 1) < s.length) ? s[i + 1] : '\0'; + if ( + (prev >= 'a' && prev <= 'z') || + ( + next != '\0' && + prev >= 'A' && prev <= 'Z' && + !(next >= 'A' && next <= 'Z') + ) + ) { + buf ~= '-'; + } + } + buf ~= (c >= 'A' && c <= 'Z') ? (c + 32) : c; + } + return cast(string)buf; +}; + +template witNameOf(alias Symbol) { + alias udas = AliasSeq!(); + static foreach (uda; __traits(getAttributes, Symbol)) { + static if ((!is(uda) && is(typeof(uda) == witExport)) || is(uda == witExport)) { + udas = AliasSeq!(udas, uda); + } + } + + static assert( + udas.length <= 1, + "There must be at most one `@witExport` attached. Found multiple on `", + __traits(fullyQualifiedName, Symbol), "`.", + ); + + static if (udas.length) { + static if (is(udas[0])) { + enum string witNameOf = toKebabCase(__traits(identifier, Symbol)); + } else { + static assert( + udas[0].name.length, + "Specifying an empty name for `@witExport(...)` is not allowed. Found empty on `", + __traits(fullyQualifiedName, Symbol), "`. Omit the parenthesis and parameter", + " (i.e. use as `@witExport`) or specify non-empty name.", + ); + enum string witNameOf = udas[0].name; + } + } else { + enum string witNameOf = ""; + } +} + +template witNameInResourceOf(T, alias Func) { + enum resName = witNameOf!T; + enum name = witNameOf!Func; + + static if (name == "[constructor]") { + enum witNameInResourceOf = "[constructor]" ~ resName; + } else { + enum witNameInResourceOf = (__traits(isStaticFunction, Func) ? "[static]" : "[method]") ~ resName ~ "." ~ name; + } +} + +template findWitExportFunc(string mod, string name, Sig, Impl...) { + static foreach(Func; Impl) { + static if (witNameOf!Func == name && witInterfaceOf!Func == mod) { + static assert( + !is(Func) && + (is(typeof(Func) == function)), + "The implementation of '", mod, "#", name, "' ", + "`", __traits(fullyQualifiedName, findWitExportFunc), "` ", + "must be a function or method." + ); + + static assert( + !is(typeof(findWitExportFunc) == void) || __traits(isSame, findWitExportFunc, Func), + "There must be only one implementation of '", mod, "#", name, "'. ", + "Found at least `", __traits(fullyQualifiedName, findWitExportFunc), + "` and `", __traits(fullyQualifiedName, Func), "`." + ); + alias findWitExportFunc = Func; + } + } + + static assert( + !is(typeof(findWitExportFunc) == void), + "Could not find implementation for '", mod, "#", name, "'" + ); + + static assert( + __traits(isStaticFunction, findWitExportFunc), + "The implementation of '", mod, "#", name, "' ", + "`", __traits(fullyQualifiedName, findWitExportFunc), "` ", + "must be static.", + ); + + static assert( + is(typeof(&findWitExportFunc) : Sig), + "The implementation of '", mod, "#", name, "' ", + "`", __traits(fullyQualifiedName, findWitExportFunc), "` ", + "must conform to the necessary signature. ", + "Found `", typeof(&findWitExportFunc), "`", + ", but expected `", Sig, "`" + ); +} + +template findWitExportMethod(T, string name, Sig, bool isStatic) { + alias Impl = witExportsIn!T; + + enum mod = witInterfaceOf!T; + + static foreach(Func; Impl) { + static if (witNameInResourceOf!(T, Func) == name) { + static assert( + !is(Func) && + (is(typeof(Func) == function)), + "The implementation of '", mod, "#", name, "' ", + "`", __traits(fullyQualifiedName, findWitExportMethod), "` ", + "must be a function or method." + ); + + static assert( + !is(typeof(findWitExportMethod) == void) || __traits(isSame, findWitExportMethod, Func), + "There must be only one implementation of '", mod, "#", name, "'. ", + "Found at least `", __traits(fullyQualifiedName, findWitExportMethod), + "` and `", __traits(fullyQualifiedName, Func), "`." + ); + alias findWitExportMethod = Func; + } + } + + static assert( + !is(typeof(findWitExportMethod) == void), + "Could not find implementation for '", mod, "#", name, "'" + ); + + static assert( + __traits(isStaticFunction, findWitExportMethod) == isStatic, + "The implementation of '", mod, "#", name, "' ", + "`", __traits(fullyQualifiedName, findWitExportMethod), "` ", + "must " ~ (isSttic ? "be static" : "have implicit `this`") ~ ".", + ); + + static assert( + is(typeof(&findWitExportMethod) : Sig), + "The implementation of '", mod, "#", name, "' ", + "`", __traits(fullyQualifiedName, findWitExportMethod), "` ", + "must conform to the necessary signature. ", + "Found `", typeof(&findWitExportMethod), "`", + ", but expected `", Sig, "`" + ); +} + +template findWitExportResource(string mod, string name, Impl...) { + static foreach(Resource; Impl) { + static if (witNameOf!Resource == name && witInterfaceOf!Resource == mod) { + static assert( + is(Resource == struct), + "The implementation of '", mod, "#", name, "' ", + "`", __traits(fullyQualifiedName, findWitExportResource), "` ", + "must be a struct." + ); + + static assert( + !is(typeof(findWitExportResource) == void) || __traits(isSame, findWitExportResource, Resource), + "There must be only one implementation of '", mod, "#", name, "'. ", + "Found at least `", __traits(fullyQualifiedName, findWitExportResource), + "` and `", __traits(fullyQualifiedName, Resource), "`." + ); + alias findWitExportResource = Resource; + } + } + + static assert( + !is(typeof(findWitExportResource) == void), + "Could not find implementation for '", mod, "#", name, "'" + ); +} + +public template witExportsIn(T) { + alias witExportsIn = AliasSeq!(); + + static foreach(member; __traits(allMembers, T)) { + witExportsIn = AliasSeq!(witExportsIn, findWitExports!(__traits(getOverloads, T, member))); + } +} + +public template findWitExports(Exports...) { + alias findWitExports = AliasSeq!(); + + static foreach (elem; Exports) { + static foreach(uda; __traits(getAttributes, elem)) { + static if ((!is(uda) && is(typeof(uda) == witExport)) || is(uda == witExport)) { + findWitExports = AliasSeq!(findWitExports, elem); + } + } + } +} + +struct DeallocateBuffer { + @nogc nothrow: + struct Page { + void*[32] slots; + static assert(slots.length < 256); + + ubyte cursor; + Page* next; + } + + Page first; + Page* head; + + @disable this(this); + + private void allocNewPage() { + Page* page = cast(Page*)malloc(Page.sizeof); + if (page is null) abort(); + + *page = Page.init; + page.next = head; + head = page; + } + + void opOpAssign(string op: "~")(void* ptr) { + import core.builtins : unlikely; + + if (unlikely(ptr is null)) return; + if (/*unlikely?*/(head is null)) head = &first; + + if (head.cursor >= head.slots.length) allocNewPage(); + + head.slots[head.cursor++] = ptr; + } + + void purge() { + auto page = head; + while (page) { + foreach (ptr; page.slots[0..page.cursor]) free(ptr); + + auto next = page.next; + if (page != &first) free(page); + page = next; + } + + first = Page.init; + head = null; + } + + ~this() { + purge(); + } +} + +version (CRuntime_WASI) { + version (WASIp1) {} + else version = LibcDefinesCABIRealloc; +} + +version (LibcDefinesCABIRealloc) {} +else +@wasmExport!("cabi_realloc") +void* cabi_realloc(void *ptr, size_t oldSize, size_t alignment, size_t newSize) { + if (newSize == 0) return cast(void*)alignment; + void *ret = realloc(ptr, newSize); + if (!ret) abort(); + return ret; +} diff --git a/src/wit/pumpkin/plugin/advancement/common.d b/src/wit/pumpkin/plugin/advancement/common.d new file mode 100644 index 0000000..e3f6775 --- /dev/null +++ b/src/wit/pumpkin/plugin/advancement/common.d @@ -0,0 +1,73 @@ +/++ + ++/ +module wit.pumpkin.plugin.advancement.common; + + +import wit.common; + +static import wit.pumpkin.plugin.text.common; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ +Frame type for an advancement. ++/ +enum FrameType : ubyte { + /++ + + +/ + task, + + /++ + + +/ + challenge, + + /++ + + +/ + goal, +} +/++ +Represents progress of an advancement for a player. ++/ +struct AdvancementProgress { + /++ + + +/ + WitString advancementId; + + /++ + + +/ + bool done; + + /++ + + +/ + WitList!(WitString) awardedCriteria; + + /++ + + +/ + WitList!(WitString) remainingCriteria; + + void witFree() @nogc nothrow { + advancementId.witFree; + awardedCriteria.witFree; + remainingCriteria.witFree; + } + + void witDrop() @nogc nothrow { + } + + AdvancementProgress witClone() const @nogc nothrow { + AdvancementProgress clone = void; + clone.advancementId = this.advancementId.witClone; + clone.done = this.done.witClone; + clone.awardedCriteria = this.awardedCriteria.witClone; + clone.remainingCriteria = this.remainingCriteria.witClone; + return clone; + } +} diff --git a/src/wit/pumpkin/plugin/advancement/imports.d b/src/wit/pumpkin/plugin/advancement/imports.d new file mode 100644 index 0000000..d3eb904 --- /dev/null +++ b/src/wit/pumpkin/plugin/advancement/imports.d @@ -0,0 +1,136 @@ +/++ + ++/ +module wit.pumpkin.plugin.advancement.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.advancement.common; + +static import wit.pumpkin.plugin.text.imports; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias TextComponent = wit.pumpkin.plugin.text.imports.TextComponent; + +/++ +Display information for an advancement. ++/ +struct AdvancementDisplay { + /++ + + +/ + TextComponent title; + + /++ + + +/ + TextComponent description; + + /++ + + +/ + FrameType frame; + + /++ + + +/ + bool showToast; + + /++ + + +/ + bool hidden; + + /++ + + +/ + bool announceToChat; + + /++ + + +/ + Option!(WitString) background; + + /++ + + +/ + float x; + + /++ + + +/ + float y; + + void witFree() @nogc nothrow { + background.witFree; + } + + void witDrop() @nogc nothrow { + title.witDrop; + description.witDrop; + } + + AdvancementDisplay witClone() const @nogc nothrow { + AdvancementDisplay clone = void; + clone.title = this.title.witClone; + clone.description = this.description.witClone; + clone.frame = this.frame.witClone; + clone.showToast = this.showToast.witClone; + clone.hidden = this.hidden.witClone; + clone.announceToChat = this.announceToChat.witClone; + clone.background = this.background.witClone; + clone.x = this.x.witClone; + clone.y = this.y.witClone; + return clone; + } +} + +/++ +Detailed information about an advancement. ++/ +struct AdvancementInfo { + /++ + + +/ + WitString id; + + /++ + + +/ + Option!(WitString) parentId; + + /++ + + +/ + WitList!(WitString) criteria; + + /++ + + +/ + Option!(AdvancementDisplay) display; + + void witFree() @nogc nothrow { + id.witFree; + parentId.witFree; + criteria.witFree; + display.witFree; + } + + void witDrop() @nogc nothrow { + display.witDrop; + } + + AdvancementInfo witClone() const @nogc nothrow { + AdvancementInfo clone = void; + clone.id = this.id.witClone; + clone.parentId = this.parentId.witClone; + clone.criteria = this.criteria.witClone; + clone.display = this.display.witClone; + return clone; + } +} diff --git a/src/wit/pumpkin/plugin/attributes/common.d b/src/wit/pumpkin/plugin/attributes/common.d new file mode 100644 index 0000000..8cf4fa3 --- /dev/null +++ b/src/wit/pumpkin/plugin/attributes/common.d @@ -0,0 +1,268 @@ +/++ + ++/ +module wit.pumpkin.plugin.attributes.common; + + +import wit.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +enum Attribute : ubyte { + /++ + + +/ + airDragModifier, + + /++ + + +/ + armor, + + /++ + + +/ + armorToughness, + + /++ + + +/ + attackDamage, + + /++ + + +/ + attackKnockback, + + /++ + + +/ + attackSpeed, + + /++ + + +/ + belowNameDistance, + + /++ + + +/ + blockBreakSpeed, + + /++ + + +/ + blockInteractionRange, + + /++ + + +/ + bounciness, + + /++ + + +/ + burningTime, + + /++ + + +/ + cameraDistance, + + /++ + + +/ + explosionKnockbackResistance, + + /++ + + +/ + entityInteractionRange, + + /++ + + +/ + fallDamageMultiplier, + + /++ + + +/ + flyingSpeed, + + /++ + + +/ + followRange, + + /++ + + +/ + frictionModifier, + + /++ + + +/ + gravity, + + /++ + + +/ + jumpStrength, + + /++ + + +/ + knockbackResistance, + + /++ + + +/ + luck, + + /++ + + +/ + maxAbsorption, + + /++ + + +/ + maxHealth, + + /++ + + +/ + miningEfficiency, + + /++ + + +/ + movementEfficiency, + + /++ + + +/ + movementSpeed, + + /++ + + +/ + nameTagDistance, + + /++ + + +/ + oxygenBonus, + + /++ + + +/ + safeFallDistance, + + /++ + + +/ + scale, + + /++ + + +/ + sneakingSpeed, + + /++ + + +/ + spawnReinforcements, + + /++ + + +/ + stepHeight, + + /++ + + +/ + submergedMiningSpeed, + + /++ + + +/ + sweepingDamageRatio, + + /++ + + +/ + temptRange, + + /++ + + +/ + waterMovementEfficiency, + + /++ + + +/ + waypointTransmitRange, + + /++ + + +/ + waypointReceiveRange, +} +/++ + ++/ +enum ModifierOperation : ubyte { + /++ + + +/ + add, + + /++ + + +/ + multiplyBase, + + /++ + + +/ + multiplyTotal, +} +/++ + ++/ +struct AttributeModifier { + /++ + + +/ + WitString id; + + /++ + + +/ + double amount; + + /++ + + +/ + ModifierOperation operation; + + void witFree() @nogc nothrow { + id.witFree; + } + + void witDrop() @nogc nothrow { + } + + AttributeModifier witClone() const @nogc nothrow { + AttributeModifier clone = void; + clone.id = this.id.witClone; + clone.amount = this.amount.witClone; + clone.operation = this.operation.witClone; + return clone; + } +} diff --git a/src/wit/pumpkin/plugin/attributes/imports.d b/src/wit/pumpkin/plugin/attributes/imports.d new file mode 100644 index 0000000..4f94dd4 --- /dev/null +++ b/src/wit/pumpkin/plugin/attributes/imports.d @@ -0,0 +1,12 @@ +/++ + ++/ +module wit.pumpkin.plugin.attributes.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.attributes.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); diff --git a/src/wit/pumpkin/plugin/bedrock_packets/common.d b/src/wit/pumpkin/plugin/bedrock_packets/common.d new file mode 100644 index 0000000..ff67308 --- /dev/null +++ b/src/wit/pumpkin/plugin/bedrock_packets/common.d @@ -0,0 +1,12018 @@ +/++ + ++/ +module wit.pumpkin.plugin.bedrock_packets.common; + + +import wit.common; + +static import wit.pumpkin.plugin.uuid.common; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias Uuid = wit.pumpkin.plugin.uuid.common.Uuid; + +/++ + ++/ +enum ActorEventId : ubyte { + /++ + + +/ + none, + + /++ + + +/ + jump, + + /++ + + +/ + hurt, + + /++ + + +/ + death, + + /++ + + +/ + startAttacking, + + /++ + + +/ + stopAttacking, + + /++ + + +/ + tamingFailed, + + /++ + + +/ + tamingSucceeded, + + /++ + + +/ + shakeWetness, + + /++ + + +/ + eatGrass, + + /++ + + +/ + fishhookBubble, + + /++ + + +/ + fishhookFishPos, + + /++ + + +/ + fishhookHookTime, + + /++ + + +/ + fishhookTease, + + /++ + + +/ + squidFleeing, + + /++ + + +/ + zombieConverting, + + /++ + + +/ + playAmbient, + + /++ + + +/ + spawnAlive, + + /++ + + +/ + startOfferFlower, + + /++ + + +/ + stopOfferFlower, + + /++ + + +/ + loveHearts, + + /++ + + +/ + villagerAngry, + + /++ + + +/ + villagerHappy, + + /++ + + +/ + witchHatMagic, + + /++ + + +/ + fireworksExplode, + + /++ + + +/ + inLoveHearts, + + /++ + + +/ + silverfishMergeAnimation, + + /++ + + +/ + guardianAttackSound, + + /++ + + +/ + drinkPotion, + + /++ + + +/ + throwPotion, + + /++ + + +/ + primeTntCart, + + /++ + + +/ + primeCreeper, + + /++ + + +/ + airSupply, + + /++ + + +/ + deprecatedAddPlayerLevels, + + /++ + + +/ + guardianMiningFatigue, + + /++ + + +/ + agentSwingArm, + + /++ + + +/ + dragonStartDeathAnim, + + /++ + + +/ + groundDust, + + /++ + + +/ + shake, + + /++ + + +/ + feed, + + /++ + + +/ + babyAge, + + /++ + + +/ + instantDeath, + + /++ + + +/ + notifyTrade, + + /++ + + +/ + leashDestroyed, + + /++ + + +/ + caravanUpdated, + + /++ + + +/ + talismanActivate, + + /++ + + +/ + deprecatedUpdateStructureFeature, + + /++ + + +/ + playerSpawnedMob, + + /++ + + +/ + puke, + + /++ + + +/ + updateStackSize, + + /++ + + +/ + startSwimming, + + /++ + + +/ + balloonPop, + + /++ + + +/ + treasureHunt, + + /++ + + +/ + summonAgent, + + /++ + + +/ + finishedChargingItem, + + /++ + + +/ + actorGrowUp, + + /++ + + +/ + vibrationDetected, + + /++ + + +/ + drinkMilk, + + /++ + + +/ + shakeWetnessStop, + + /++ + + +/ + kineticDamageDealt, + + /++ + + +/ + hurtWithoutReceivingDamage, +} +/++ + ++/ +struct SActorEvent { + /++ + + +/ + long targetRuntimeId; + + /++ + + +/ + ActorEventId eventId; + + /++ + + +/ + int data; + + /++ + + +/ + Option!(Tuple!(double, double, double)) fireAtPosition; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SActorEvent witClone() const @nogc nothrow { + SActorEvent clone = void; + clone.targetRuntimeId = this.targetRuntimeId.witClone; + clone.eventId = this.eventId.witClone; + clone.data = this.data.witClone; + clone.fireAtPosition = this.fireAtPosition.witClone; + return clone; + } +} + +/++ + ++/ +enum AnimateAction : ubyte { + /++ + + +/ + noAction, + + /++ + + +/ + swingArm, + + /++ + + +/ + wakeUp, + + /++ + + +/ + criticalHit, + + /++ + + +/ + magicCriticalHit, +} +/++ + ++/ +enum ActorSwingSource : ubyte { + /++ + + +/ + none, + + /++ + + +/ + build, + + /++ + + +/ + mine, + + /++ + + +/ + interact, + + /++ + + +/ + attack, + + /++ + + +/ + useItem, + + /++ + + +/ + throwItem, + + /++ + + +/ + dropItem, + + /++ + + +/ + event, +} +/++ + ++/ +struct SAnimate { + /++ + + +/ + AnimateAction action; + + /++ + + +/ + long targetActorRuntimeId; + + /++ + + +/ + float data; + + /++ + + +/ + Option!(ActorSwingSource) swingSource; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SAnimate witClone() const @nogc nothrow { + SAnimate clone = void; + clone.action = this.action.witClone; + clone.targetActorRuntimeId = this.targetActorRuntimeId.witClone; + clone.data = this.data.witClone; + clone.swingSource = this.swingSource.witClone; + return clone; + } +} + +/++ + ++/ +struct SBlockPickRequest { + /++ + + +/ + Tuple!(int, int, int) position; + + /++ + + +/ + bool withData; + + /++ + + +/ + ubyte maxSlots; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SBlockPickRequest witClone() const @nogc nothrow { + SBlockPickRequest clone = void; + clone.position = this.position.witClone; + clone.withData = this.withData.witClone; + clone.maxSlots = this.maxSlots.witClone; + return clone; + } +} + +/++ + ++/ +struct SClientCacheBlobStatus { + /++ + + +/ + WitList!(long) missHashes; + + /++ + + +/ + WitList!(long) hitHashes; + + void witFree() @nogc nothrow { + missHashes.witFree; + hitHashes.witFree; + } + + void witDrop() @nogc nothrow { + } + + SClientCacheBlobStatus witClone() const @nogc nothrow { + SClientCacheBlobStatus clone = void; + clone.missHashes = this.missHashes.witClone; + clone.hitHashes = this.hitHashes.witClone; + return clone; + } +} + +/++ + ++/ +struct SClientCacheStatus { + /++ + + +/ + bool isCacheSupported; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SClientCacheStatus witClone() const @nogc nothrow { + SClientCacheStatus clone = void; + clone.isCacheSupported = this.isCacheSupported.witClone; + return clone; + } +} + +/++ + ++/ +struct CommandOriginData { + /++ + + +/ + WitString rType; + + /++ + + +/ + Uuid uuid; + + /++ + + +/ + WitString requestId; + + /++ + + +/ + long playerId; + + void witFree() @nogc nothrow { + rType.witFree; + requestId.witFree; + } + + void witDrop() @nogc nothrow { + } + + CommandOriginData witClone() const @nogc nothrow { + CommandOriginData clone = void; + clone.rType = this.rType.witClone; + clone.uuid = this.uuid.witClone; + clone.requestId = this.requestId.witClone; + clone.playerId = this.playerId.witClone; + return clone; + } +} + +/++ + ++/ +struct SCommandRequest { + /++ + + +/ + WitString command; + + /++ + + +/ + CommandOriginData origin; + + /++ + + +/ + bool isInternal; + + /++ + + +/ + WitString version_; + + void witFree() @nogc nothrow { + command.witFree; + origin.witFree; + version_.witFree; + } + + void witDrop() @nogc nothrow { + } + + SCommandRequest witClone() const @nogc nothrow { + SCommandRequest clone = void; + clone.command = this.command.witClone; + clone.origin = this.origin.witClone; + clone.isInternal = this.isInternal.witClone; + clone.version_ = this.version_.witClone; + return clone; + } +} + +/++ + ++/ +struct SContainerClose { + /++ + + +/ + ubyte containerId; + + /++ + + +/ + ubyte containerType; + + /++ + + +/ + bool serverInitiatedClose; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SContainerClose witClone() const @nogc nothrow { + SContainerClose clone = void; + clone.containerId = this.containerId.witClone; + clone.containerType = this.containerType.witClone; + clone.serverInitiatedClose = this.serverInitiatedClose.witClone; + return clone; + } +} + +/++ + ++/ +struct SEmote { + /++ + + +/ + long actorRuntimeId; + + /++ + + +/ + WitString emoteId; + + /++ + + +/ + int emoteLengthTicks; + + /++ + + +/ + WitString xuid; + + /++ + + +/ + WitString platformId; + + /++ + + +/ + ubyte flags; + + void witFree() @nogc nothrow { + emoteId.witFree; + xuid.witFree; + platformId.witFree; + } + + void witDrop() @nogc nothrow { + } + + SEmote witClone() const @nogc nothrow { + SEmote clone = void; + clone.actorRuntimeId = this.actorRuntimeId.witClone; + clone.emoteId = this.emoteId.witClone; + clone.emoteLengthTicks = this.emoteLengthTicks.witClone; + clone.xuid = this.xuid.witClone; + clone.platformId = this.platformId.witClone; + clone.flags = this.flags.witClone; + return clone; + } +} + +/++ + ++/ +struct SEmoteList { + /++ + + +/ + long runtimeId; + + /++ + + +/ + WitList!(Uuid) emotePieceIds; + + void witFree() @nogc nothrow { + emotePieceIds.witFree; + } + + void witDrop() @nogc nothrow { + } + + SEmoteList witClone() const @nogc nothrow { + SEmoteList clone = void; + clone.runtimeId = this.runtimeId.witClone; + clone.emotePieceIds = this.emotePieceIds.witClone; + return clone; + } +} + +/++ + ++/ +enum Action : ubyte { + /++ + + +/ + invalid, + + /++ + + +/ + stopRiding, + + /++ + + +/ + interactUpdate, + + /++ + + +/ + npcOpen, + + /++ + + +/ + openInventory, +} +/++ + ++/ +struct SInteract { + /++ + + +/ + Action action; + + /++ + + +/ + long targetRuntimeId; + + /++ + + +/ + Option!(Tuple!(double, double, double)) position; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SInteract witClone() const @nogc nothrow { + SInteract clone = void; + clone.action = this.action.witClone; + clone.targetRuntimeId = this.targetRuntimeId.witClone; + clone.position = this.position.witClone; + return clone; + } +} + +/++ + ++/ +struct InventoryActionSource { + mixin WitVariant!( + void, // container + void, // world + void, // creative + void, // todo + int, // unknown + ); + +public: + enum Tag : ubyte { + /++ + + +/ + container, + + /++ + + +/ + world, + + /++ + + +/ + creative, + + /++ + + +/ + todo, + + /++ + + +/ + unknown, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias container = _create!(Tag.container); + /// ditto + pragma(inline, true) bool isContainer() const => _tag == Tag.container; + + /++ + + +/ + alias world = _create!(Tag.world); + /// ditto + pragma(inline, true) bool isWorld() const => _tag == Tag.world; + + /++ + + +/ + alias creative = _create!(Tag.creative); + /// ditto + pragma(inline, true) bool isCreative() const => _tag == Tag.creative; + + /++ + + +/ + alias todo = _create!(Tag.todo); + /// ditto + pragma(inline, true) bool isTodo() const => _tag == Tag.todo; + + /++ + + +/ + alias unknown = _create!(Tag.unknown); + /// ditto + pragma(inline, true) bool isUnknown() const => _tag == Tag.unknown; + ///ditto + alias getUnknown = _get!(Tag.unknown); + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + InventoryActionSource witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.container: return _create!(Tag.container); break; + case Tag.world: return _create!(Tag.world); break; + case Tag.creative: return _create!(Tag.creative); break; + case Tag.todo: return _create!(Tag.todo); break; + case Tag.unknown: return _create!(Tag.unknown)(this._get!(Tag.unknown).witClone); break; + } + } +} + +/++ + ++/ +struct LegacySetItemSlot { + /++ + + +/ + ubyte containerId; + + /++ + + +/ + WitList!(ubyte) slots; + + void witFree() @nogc nothrow { + slots.witFree; + } + + void witDrop() @nogc nothrow { + } + + LegacySetItemSlot witClone() const @nogc nothrow { + LegacySetItemSlot clone = void; + clone.containerId = this.containerId.witClone; + clone.slots = this.slots.witClone; + return clone; + } +} + +/++ + ++/ +struct StackRequestItem { + /++ + + +/ + Option!(WitString) identifier; + + /++ + + +/ + int metadataValue; + + /++ + + +/ + int count; + + /++ + + +/ + int blockRuntimeId; + + /++ + + +/ + WitList!(ubyte) extraData; + + void witFree() @nogc nothrow { + identifier.witFree; + extraData.witFree; + } + + void witDrop() @nogc nothrow { + } + + StackRequestItem witClone() const @nogc nothrow { + StackRequestItem clone = void; + clone.identifier = this.identifier.witClone; + clone.metadataValue = this.metadataValue.witClone; + clone.count = this.count.witClone; + clone.blockRuntimeId = this.blockRuntimeId.witClone; + clone.extraData = this.extraData.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemStackRequestActionCreate { + /++ + + +/ + ubyte resultIndex; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ItemStackRequestActionCreate witClone() const @nogc nothrow { + ItemStackRequestActionCreate clone = void; + clone.resultIndex = this.resultIndex.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemStackRequestActionBeaconPayment { + /++ + + +/ + int primaryEffectId; + + /++ + + +/ + int secondaryEffectId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ItemStackRequestActionBeaconPayment witClone() const @nogc nothrow { + ItemStackRequestActionBeaconPayment clone = void; + clone.primaryEffectId = this.primaryEffectId.witClone; + clone.secondaryEffectId = this.secondaryEffectId.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemStackRequestActionMineBlock { + /++ + + +/ + int hotbarSlot; + + /++ + + +/ + int predictedDurability; + + /++ + + +/ + int stackId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ItemStackRequestActionMineBlock witClone() const @nogc nothrow { + ItemStackRequestActionMineBlock clone = void; + clone.hotbarSlot = this.hotbarSlot.witClone; + clone.predictedDurability = this.predictedDurability.witClone; + clone.stackId = this.stackId.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemStackRequestActionCraftRecipe { + /++ + + +/ + int recipeId; + + /++ + + +/ + ubyte repetitions; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ItemStackRequestActionCraftRecipe witClone() const @nogc nothrow { + ItemStackRequestActionCraftRecipe clone = void; + clone.recipeId = this.recipeId.witClone; + clone.repetitions = this.repetitions.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemStackRequestActionCraftRecipeAuto { + /++ + + +/ + int recipeId; + + /++ + + +/ + ubyte repetitions; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ItemStackRequestActionCraftRecipeAuto witClone() const @nogc nothrow { + ItemStackRequestActionCraftRecipeAuto clone = void; + clone.recipeId = this.recipeId.witClone; + clone.repetitions = this.repetitions.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemStackRequestActionCraftCreative { + /++ + + +/ + int creativeItemId; + + /++ + + +/ + ubyte repetitions; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ItemStackRequestActionCraftCreative witClone() const @nogc nothrow { + ItemStackRequestActionCraftCreative clone = void; + clone.creativeItemId = this.creativeItemId.witClone; + clone.repetitions = this.repetitions.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemStackRequestActionOptional { + /++ + + +/ + int recipeId; + + /++ + + +/ + int filterStringIndex; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ItemStackRequestActionOptional witClone() const @nogc nothrow { + ItemStackRequestActionOptional clone = void; + clone.recipeId = this.recipeId.witClone; + clone.filterStringIndex = this.filterStringIndex.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemStackRequestActionGrindstone { + /++ + + +/ + int recipeId; + + /++ + + +/ + int repairCost; + + /++ + + +/ + ubyte repetitions; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ItemStackRequestActionGrindstone witClone() const @nogc nothrow { + ItemStackRequestActionGrindstone clone = void; + clone.recipeId = this.recipeId.witClone; + clone.repairCost = this.repairCost.witClone; + clone.repetitions = this.repetitions.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemStackRequestActionLoom { + /++ + + +/ + WitString patternId; + + /++ + + +/ + ubyte repetitions; + + void witFree() @nogc nothrow { + patternId.witFree; + } + + void witDrop() @nogc nothrow { + } + + ItemStackRequestActionLoom witClone() const @nogc nothrow { + ItemStackRequestActionLoom clone = void; + clone.patternId = this.patternId.witClone; + clone.repetitions = this.repetitions.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemStackRequestActionCraftResultsDeprecated { + /++ + + +/ + WitList!(StackRequestItem) resultItems; + + /++ + + +/ + ubyte timesCrafted; + + void witFree() @nogc nothrow { + resultItems.witFree; + } + + void witDrop() @nogc nothrow { + } + + ItemStackRequestActionCraftResultsDeprecated witClone() const @nogc nothrow { + ItemStackRequestActionCraftResultsDeprecated clone = void; + clone.resultItems = this.resultItems.witClone; + clone.timesCrafted = this.timesCrafted.witClone; + return clone; + } +} + +/++ + ++/ +enum LoadingScreenPacketType : ubyte { + /++ + + +/ + startLoadingScreen, + + /++ + + +/ + endLoadingScreen, +} +/++ + ++/ +struct SLoadingScreen { + /++ + + +/ + LoadingScreenPacketType loadingScreenPacketType; + + /++ + + +/ + Option!(int) loadingScreenId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SLoadingScreen witClone() const @nogc nothrow { + SLoadingScreen clone = void; + clone.loadingScreenPacketType = this.loadingScreenPacketType.witClone; + clone.loadingScreenId = this.loadingScreenId.witClone; + return clone; + } +} + +/++ + ++/ +struct SLogin { + /++ + + +/ + int protocolVersion; + + /++ + + +/ + WitList!(ubyte) jwt; + + /++ + + +/ + WitList!(ubyte) rawToken; + + void witFree() @nogc nothrow { + jwt.witFree; + rawToken.witFree; + } + + void witDrop() @nogc nothrow { + } + + SLogin witClone() const @nogc nothrow { + SLogin clone = void; + clone.protocolVersion = this.protocolVersion.witClone; + clone.jwt = this.jwt.witClone; + clone.rawToken = this.rawToken.witClone; + return clone; + } +} + +/++ + ++/ +struct SkinAnimation { + /++ + + +/ + double frames; + + /++ + + +/ + WitString image; + + /++ + + +/ + int imageHeight; + + /++ + + +/ + int imageWidth; + + /++ + + +/ + int animationType; + + /++ + + +/ + int animationExpression; + + void witFree() @nogc nothrow { + image.witFree; + } + + void witDrop() @nogc nothrow { + } + + SkinAnimation witClone() const @nogc nothrow { + SkinAnimation clone = void; + clone.frames = this.frames.witClone; + clone.image = this.image.witClone; + clone.imageHeight = this.imageHeight.witClone; + clone.imageWidth = this.imageWidth.witClone; + clone.animationType = this.animationType.witClone; + clone.animationExpression = this.animationExpression.witClone; + return clone; + } +} + +/++ + ++/ +struct PersonaPiece { + /++ + + +/ + bool isDefault; + + /++ + + +/ + WitString packId; + + /++ + + +/ + WitString pieceId; + + /++ + + +/ + WitString pieceType; + + /++ + + +/ + WitString productId; + + void witFree() @nogc nothrow { + packId.witFree; + pieceId.witFree; + pieceType.witFree; + productId.witFree; + } + + void witDrop() @nogc nothrow { + } + + PersonaPiece witClone() const @nogc nothrow { + PersonaPiece clone = void; + clone.isDefault = this.isDefault.witClone; + clone.packId = this.packId.witClone; + clone.pieceId = this.pieceId.witClone; + clone.pieceType = this.pieceType.witClone; + clone.productId = this.productId.witClone; + return clone; + } +} + +/++ + ++/ +struct PersonaPieceTintColour { + /++ + + +/ + WitList!(WitString) colours; + + /++ + + +/ + WitString pieceType; + + void witFree() @nogc nothrow { + colours.witFree; + pieceType.witFree; + } + + void witDrop() @nogc nothrow { + } + + PersonaPieceTintColour witClone() const @nogc nothrow { + PersonaPieceTintColour clone = void; + clone.colours = this.colours.witClone; + clone.pieceType = this.pieceType.witClone; + return clone; + } +} + +/++ + ++/ +struct ClientData { + /++ + + +/ + long clientRandomId; + + /++ + + +/ + int deviceOs; + + /++ + + +/ + WitString deviceId; + + /++ + + +/ + WitString gameVersion; + + /++ + + +/ + WitString languageCode; + + /++ + + +/ + int currentInputMode; + + /++ + + +/ + int defaultInputMode; + + /++ + + +/ + int uiProfile; + + /++ + + +/ + WitString serverAddress; + + /++ + + +/ + WitString deviceModel; + + /++ + + +/ + int guiScale; + + /++ + + +/ + bool clientIsEditorCapable; + + /++ + + +/ + int clientEditorConnectionIntent; + + /++ + + +/ + int maxViewDistance; + + /++ + + +/ + int memoryTier; + + /++ + + +/ + int platformType; + + /++ + + +/ + int graphicsMode; + + /++ + + +/ + bool compatibleWithClientSideChunkGen; + + /++ + + +/ + WitString platformOfflineId; + + /++ + + +/ + WitString platformOnlineId; + + /++ + + +/ + WitString platformUserId; + + /++ + + +/ + WitString selfSignedId; + + /++ + + +/ + WitString playFabId; + + /++ + + +/ + WitString thirdPartyName; + + /++ + + +/ + bool thirdPartyNameOnly; + + /++ + + +/ + WitString skinId; + + /++ + + +/ + WitString skinData; + + /++ + + +/ + int skinImageHeight; + + /++ + + +/ + int skinImageWidth; + + /++ + + +/ + WitString skinColour; + + /++ + + +/ + WitString armSize; + + /++ + + +/ + bool personaSkin; + + /++ + + +/ + bool premiumSkin; + + /++ + + +/ + bool trustedSkin; + + /++ + + +/ + bool overrideSkin; + + /++ + + +/ + WitString capeData; + + /++ + + +/ + WitString capeId; + + /++ + + +/ + int capeImageHeight; + + /++ + + +/ + int capeImageWidth; + + /++ + + +/ + bool capeOnClassicSkin; + + /++ + + +/ + WitString skinGeometry; + + /++ + + +/ + WitString skinGeometryVersion; + + /++ + + +/ + WitString skinResourcePatch; + + /++ + + +/ + WitList!(SkinAnimation) animatedImageData; + + /++ + + +/ + WitString skinAnimationData; + + /++ + + +/ + WitList!(PersonaPiece) personaPieces; + + /++ + + +/ + WitList!(PersonaPieceTintColour) pieceTintColours; + + void witFree() @nogc nothrow { + deviceId.witFree; + gameVersion.witFree; + languageCode.witFree; + serverAddress.witFree; + deviceModel.witFree; + platformOfflineId.witFree; + platformOnlineId.witFree; + platformUserId.witFree; + selfSignedId.witFree; + playFabId.witFree; + thirdPartyName.witFree; + skinId.witFree; + skinData.witFree; + skinColour.witFree; + armSize.witFree; + capeData.witFree; + capeId.witFree; + skinGeometry.witFree; + skinGeometryVersion.witFree; + skinResourcePatch.witFree; + animatedImageData.witFree; + skinAnimationData.witFree; + personaPieces.witFree; + pieceTintColours.witFree; + } + + void witDrop() @nogc nothrow { + } + + ClientData witClone() const @nogc nothrow { + ClientData clone = void; + clone.clientRandomId = this.clientRandomId.witClone; + clone.deviceOs = this.deviceOs.witClone; + clone.deviceId = this.deviceId.witClone; + clone.gameVersion = this.gameVersion.witClone; + clone.languageCode = this.languageCode.witClone; + clone.currentInputMode = this.currentInputMode.witClone; + clone.defaultInputMode = this.defaultInputMode.witClone; + clone.uiProfile = this.uiProfile.witClone; + clone.serverAddress = this.serverAddress.witClone; + clone.deviceModel = this.deviceModel.witClone; + clone.guiScale = this.guiScale.witClone; + clone.clientIsEditorCapable = this.clientIsEditorCapable.witClone; + clone.clientEditorConnectionIntent = this.clientEditorConnectionIntent.witClone; + clone.maxViewDistance = this.maxViewDistance.witClone; + clone.memoryTier = this.memoryTier.witClone; + clone.platformType = this.platformType.witClone; + clone.graphicsMode = this.graphicsMode.witClone; + clone.compatibleWithClientSideChunkGen = this.compatibleWithClientSideChunkGen.witClone; + clone.platformOfflineId = this.platformOfflineId.witClone; + clone.platformOnlineId = this.platformOnlineId.witClone; + clone.platformUserId = this.platformUserId.witClone; + clone.selfSignedId = this.selfSignedId.witClone; + clone.playFabId = this.playFabId.witClone; + clone.thirdPartyName = this.thirdPartyName.witClone; + clone.thirdPartyNameOnly = this.thirdPartyNameOnly.witClone; + clone.skinId = this.skinId.witClone; + clone.skinData = this.skinData.witClone; + clone.skinImageHeight = this.skinImageHeight.witClone; + clone.skinImageWidth = this.skinImageWidth.witClone; + clone.skinColour = this.skinColour.witClone; + clone.armSize = this.armSize.witClone; + clone.personaSkin = this.personaSkin.witClone; + clone.premiumSkin = this.premiumSkin.witClone; + clone.trustedSkin = this.trustedSkin.witClone; + clone.overrideSkin = this.overrideSkin.witClone; + clone.capeData = this.capeData.witClone; + clone.capeId = this.capeId.witClone; + clone.capeImageHeight = this.capeImageHeight.witClone; + clone.capeImageWidth = this.capeImageWidth.witClone; + clone.capeOnClassicSkin = this.capeOnClassicSkin.witClone; + clone.skinGeometry = this.skinGeometry.witClone; + clone.skinGeometryVersion = this.skinGeometryVersion.witClone; + clone.skinResourcePatch = this.skinResourcePatch.witClone; + clone.animatedImageData = this.animatedImageData.witClone; + clone.skinAnimationData = this.skinAnimationData.witClone; + clone.personaPieces = this.personaPieces.witClone; + clone.pieceTintColours = this.pieceTintColours.witClone; + return clone; + } +} + +/++ + ++/ +struct SModalFormResponse { + /++ + + +/ + int formId; + + /++ + + +/ + Option!(WitString) jsonResponse; + + /++ + + +/ + Option!(ubyte) formCancelReason; + + void witFree() @nogc nothrow { + jsonResponse.witFree; + } + + void witDrop() @nogc nothrow { + } + + SModalFormResponse witClone() const @nogc nothrow { + SModalFormResponse clone = void; + clone.formId = this.formId.witClone; + clone.jsonResponse = this.jsonResponse.witClone; + clone.formCancelReason = this.formCancelReason.witClone; + return clone; + } +} + +/++ + ++/ +struct SPacketViolationWarning { + /++ + + +/ + int violationType; + + /++ + + +/ + int violationSeverity; + + /++ + + +/ + int violationPacketId; + + /++ + + +/ + WitString violationContext; + + void witFree() @nogc nothrow { + violationContext.witFree; + } + + void witDrop() @nogc nothrow { + } + + SPacketViolationWarning witClone() const @nogc nothrow { + SPacketViolationWarning clone = void; + clone.violationType = this.violationType.witClone; + clone.violationSeverity = this.violationSeverity.witClone; + clone.violationPacketId = this.violationPacketId.witClone; + clone.violationContext = this.violationContext.witClone; + return clone; + } +} + +/++ + ++/ +enum PlayerActionType : ubyte { + /++ + + +/ + unknown, + + /++ + + +/ + startDestroyBlock, + + /++ + + +/ + abortDestroyBlock, + + /++ + + +/ + stopDestroyBlock, + + /++ + + +/ + getUpdatedBlock, + + /++ + + +/ + dropItem, + + /++ + + +/ + startSleeping, + + /++ + + +/ + stopSleeping, + + /++ + + +/ + respawn, + + /++ + + +/ + startJump, + + /++ + + +/ + startSprinting, + + /++ + + +/ + stopSprinting, + + /++ + + +/ + startSneaking, + + /++ + + +/ + stopSneaking, + + /++ + + +/ + creativeDestroyBlock, + + /++ + + +/ + changeDimensionAck, + + /++ + + +/ + startGliding, + + /++ + + +/ + stopGliding, + + /++ + + +/ + denyDestroyBlock, + + /++ + + +/ + crackBlock, + + /++ + + +/ + changeSkin, + + /++ + + +/ + updatedEnchantingSeed, + + /++ + + +/ + startSwimming, + + /++ + + +/ + stopSwimming, + + /++ + + +/ + startSpinAttack, + + /++ + + +/ + stopSpinAttack, + + /++ + + +/ + interactWithBlock, + + /++ + + +/ + predictDestroyBlock, + + /++ + + +/ + continueDestroyBlock, + + /++ + + +/ + startItemUseOn, + + /++ + + +/ + stopItemUseOn, + + /++ + + +/ + handledTeleport, + + /++ + + +/ + missedSwing, + + /++ + + +/ + startCrawling, + + /++ + + +/ + stopCrawling, + + /++ + + +/ + startFlying, + + /++ + + +/ + stopFlying, + + /++ + + +/ + clientAckServerData, + + /++ + + +/ + startUsingItem, + + /++ + + +/ + internalUpdate, + + /++ + + +/ + count, +} +/++ + ++/ +struct SPlayerAction { + /++ + + +/ + long playerRuntimeId; + + /++ + + +/ + PlayerActionType action; + + /++ + + +/ + Tuple!(int, int, int) blockPosition; + + /++ + + +/ + Tuple!(int, int, int) resultPos; + + /++ + + +/ + int face; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SPlayerAction witClone() const @nogc nothrow { + SPlayerAction clone = void; + clone.playerRuntimeId = this.playerRuntimeId.witClone; + clone.action = this.action.witClone; + clone.blockPosition = this.blockPosition.witClone; + clone.resultPos = this.resultPos.witClone; + clone.face = this.face.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerBlockAction { + /++ + + +/ + int action; + + /++ + + +/ + Tuple!(int, int, int) blockPos; + + /++ + + +/ + int face; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + PlayerBlockAction witClone() const @nogc nothrow { + PlayerBlockAction clone = void; + clone.action = this.action.witClone; + clone.blockPos = this.blockPos.witClone; + clone.face = this.face.witClone; + return clone; + } +} + +/++ + ++/ +enum InputMode : ubyte { + /++ + + +/ + mouse, + + /++ + + +/ + touch, + + /++ + + +/ + gamePad, + + /++ + + +/ + motionController, +} +/++ + ++/ +enum PlayMode : ubyte { + /++ + + +/ + normal, + + /++ + + +/ + teaser, + + /++ + + +/ + screen, + + /++ + + +/ + exitLevel, + + /++ + + +/ + numModes, +} +/++ + ++/ +enum InteractionModel : ubyte { + /++ + + +/ + touch, + + /++ + + +/ + crosshair, + + /++ + + +/ + classic, +} +/++ + ++/ +enum InputData : ubyte { + /++ + + +/ + ascend, + + /++ + + +/ + descend, + + /++ + + +/ + northJump, + + /++ + + +/ + jumpDown, + + /++ + + +/ + sprintDown, + + /++ + + +/ + changeHeight, + + /++ + + +/ + jumping, + + /++ + + +/ + autoJumpingInWater, + + /++ + + +/ + sneaking, + + /++ + + +/ + sneakDown, + + /++ + + +/ + up, + + /++ + + +/ + down, + + /++ + + +/ + left, + + /++ + + +/ + right, + + /++ + + +/ + upLeft, + + /++ + + +/ + upRight, + + /++ + + +/ + wantUp, + + /++ + + +/ + wantDown, + + /++ + + +/ + wantDownSlow, + + /++ + + +/ + wantUpSlow, + + /++ + + +/ + sprinting, + + /++ + + +/ + ascendBlock, + + /++ + + +/ + descendBlock, + + /++ + + +/ + sneakToggleDown, + + /++ + + +/ + persistSneak, + + /++ + + +/ + startSprinting, + + /++ + + +/ + stopSprinting, + + /++ + + +/ + startSneaking, + + /++ + + +/ + stopSneaking, + + /++ + + +/ + startSwimming, + + /++ + + +/ + stopSwimming, + + /++ + + +/ + startJumping, + + /++ + + +/ + startGliding, + + /++ + + +/ + stopGliding, + + /++ + + +/ + performItemInteraction, + + /++ + + +/ + performBlockActions, + + /++ + + +/ + performItemStackRequest, + + /++ + + +/ + handledTeleport, + + /++ + + +/ + emoting, + + /++ + + +/ + missedSwing, + + /++ + + +/ + startCrawling, + + /++ + + +/ + stopCrawling, + + /++ + + +/ + startFlying, + + /++ + + +/ + stopFlying, + + /++ + + +/ + clientAckServerData, + + /++ + + +/ + clientPredictedVehicle, + + /++ + + +/ + paddlingLeft, + + /++ + + +/ + paddlingRight, + + /++ + + +/ + blockBreakingDelayEnabled, + + /++ + + +/ + horizontalCollision, + + /++ + + +/ + verticalCollision, + + /++ + + +/ + downLeft, + + /++ + + +/ + downRight, + + /++ + + +/ + startUsingItem, + + /++ + + +/ + cameraRelativeMovementEnabled, + + /++ + + +/ + rotControlledByMoveDirection, + + /++ + + +/ + startSpinAttack, + + /++ + + +/ + stopSpinAttack, + + /++ + + +/ + isHotbarTouchOnly, + + /++ + + +/ + jumpReleasedRaw, + + /++ + + +/ + jumpPressedRaw, + + /++ + + +/ + jumpCurrentRaw, + + /++ + + +/ + sneakReleasedRaw, + + /++ + + +/ + sneakPressedRaw, + + /++ + + +/ + sneakCurrentRaw, + + /++ + + +/ + internalUpdate, +} +/++ + ++/ +struct SPlayerHotbar { + /++ + + +/ + int selectedSlot; + + /++ + + +/ + ubyte containerId; + + /++ + + +/ + bool shouldSelectSlot; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SPlayerHotbar witClone() const @nogc nothrow { + SPlayerHotbar clone = void; + clone.selectedSlot = this.selectedSlot.witClone; + clone.containerId = this.containerId.witClone; + clone.shouldSelectSlot = this.shouldSelectSlot.witClone; + return clone; + } +} + +/++ + ++/ +struct AbilityValue { + mixin WitVariant!( + bool, // bool_ + float, // float_ + ); + +public: + enum Tag : ubyte { + /++ + + +/ + bool_, + + /++ + + +/ + float_, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias bool_ = _create!(Tag.bool_); + /// ditto + pragma(inline, true) bool isBool() const => _tag == Tag.bool_; + ///ditto + alias getBool = _get!(Tag.bool_); + + /++ + + +/ + alias float_ = _create!(Tag.float_); + /// ditto + pragma(inline, true) bool isFloat() const => _tag == Tag.float_; + ///ditto + alias getFloat = _get!(Tag.float_); + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + AbilityValue witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.bool_: return _create!(Tag.bool_)(this._get!(Tag.bool_).witClone); break; + case Tag.float_: return _create!(Tag.float_)(this._get!(Tag.float_).witClone); break; + } + } +} + +/++ + ++/ +struct SRequestAbility { + /++ + + +/ + int ability; + + /++ + + +/ + AbilityValue value; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SRequestAbility witClone() const @nogc nothrow { + SRequestAbility clone = void; + clone.ability = this.ability.witClone; + clone.value = this.value.witClone; + return clone; + } +} + +/++ + ++/ +struct SRequestChunkRadius { + /++ + + +/ + int chunkRadius; + + /++ + + +/ + ubyte maxChunkRadius; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SRequestChunkRadius witClone() const @nogc nothrow { + SRequestChunkRadius clone = void; + clone.chunkRadius = this.chunkRadius.witClone; + clone.maxChunkRadius = this.maxChunkRadius.witClone; + return clone; + } +} + +/++ + ++/ +struct SRequestNetworkSettings { + /++ + + +/ + int clientNetworkVersion; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SRequestNetworkSettings witClone() const @nogc nothrow { + SRequestNetworkSettings clone = void; + clone.clientNetworkVersion = this.clientNetworkVersion.witClone; + return clone; + } +} + +/++ + ++/ +struct SResourcePackClientResponse { + /++ + + +/ + ubyte response; + + /++ + + +/ + int downloadSize; + + /++ + + +/ + WitList!(WitString) packIds; + + void witFree() @nogc nothrow { + packIds.witFree; + } + + void witDrop() @nogc nothrow { + } + + SResourcePackClientResponse witClone() const @nogc nothrow { + SResourcePackClientResponse clone = void; + clone.response = this.response.witClone; + clone.downloadSize = this.downloadSize.witClone; + clone.packIds = this.packIds.witClone; + return clone; + } +} + +/++ + ++/ +enum RespawnState : ubyte { + /++ + + +/ + searchingForSpawn, + + /++ + + +/ + readyToSpawn, + + /++ + + +/ + clientReadyToSpawn, +} +/++ + ++/ +struct SRespawn { + /++ + + +/ + Tuple!(double, double, double) position; + + /++ + + +/ + RespawnState state; + + /++ + + +/ + long playerRuntimeId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SRespawn witClone() const @nogc nothrow { + SRespawn clone = void; + clone.position = this.position.witClone; + clone.state = this.state.witClone; + clone.playerRuntimeId = this.playerRuntimeId.witClone; + return clone; + } +} + +/++ + ++/ +struct SSetLocalPlayerAsInitialized { + /++ + + +/ + long playerId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SSetLocalPlayerAsInitialized witClone() const @nogc nothrow { + SSetLocalPlayerAsInitialized clone = void; + clone.playerId = this.playerId.witClone; + return clone; + } +} + +/++ + ++/ +struct SSetPlayerInventoryOptions { + /++ + + +/ + int leftInventoryTab; + + /++ + + +/ + int rightInventoryTab; + + /++ + + +/ + bool filtering; + + /++ + + +/ + int layoutInv; + + /++ + + +/ + int layoutCraft; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SSetPlayerInventoryOptions witClone() const @nogc nothrow { + SSetPlayerInventoryOptions clone = void; + clone.leftInventoryTab = this.leftInventoryTab.witClone; + clone.rightInventoryTab = this.rightInventoryTab.witClone; + clone.filtering = this.filtering.witClone; + clone.layoutInv = this.layoutInv.witClone; + clone.layoutCraft = this.layoutCraft.witClone; + return clone; + } +} + +/++ + ++/ +enum TextPacketType : ubyte { + /++ + + +/ + raw, + + /++ + + +/ + chat, + + /++ + + +/ + translation, + + /++ + + +/ + popup, + + /++ + + +/ + jukeboxPopup, + + /++ + + +/ + tip, + + /++ + + +/ + system, + + /++ + + +/ + whisper, + + /++ + + +/ + announcement, + + /++ + + +/ + jsonWhisper, + + /++ + + +/ + json, + + /++ + + +/ + jsonAnnouncement, +} +/++ + ++/ +struct SText { + /++ + + +/ + bool needsTranslation; + + /++ + + +/ + TextPacketType rType; + + /++ + + +/ + WitString sourceName; + + /++ + + +/ + WitString message; + + /++ + + +/ + WitList!(WitString) parameters; + + /++ + + +/ + WitString xuid; + + /++ + + +/ + WitString platformChatId; + + /++ + + +/ + Option!(WitString) filteredMessage; + + void witFree() @nogc nothrow { + sourceName.witFree; + message.witFree; + parameters.witFree; + xuid.witFree; + platformChatId.witFree; + filteredMessage.witFree; + } + + void witDrop() @nogc nothrow { + } + + SText witClone() const @nogc nothrow { + SText clone = void; + clone.needsTranslation = this.needsTranslation.witClone; + clone.rType = this.rType.witClone; + clone.sourceName = this.sourceName.witClone; + clone.message = this.message.witClone; + clone.parameters = this.parameters.witClone; + clone.xuid = this.xuid.witClone; + clone.platformChatId = this.platformChatId.witClone; + clone.filteredMessage = this.filteredMessage.witClone; + return clone; + } +} + +/++ + ++/ +struct SyncedAttribute { + /++ + + +/ + WitString attributeName; + + /++ + + +/ + float minValue; + + /++ + + +/ + float currentValue; + + /++ + + +/ + float maxValue; + + void witFree() @nogc nothrow { + attributeName.witFree; + } + + void witDrop() @nogc nothrow { + } + + SyncedAttribute witClone() const @nogc nothrow { + SyncedAttribute clone = void; + clone.attributeName = this.attributeName.witClone; + clone.minValue = this.minValue.witClone; + clone.currentValue = this.currentValue.witClone; + clone.maxValue = this.maxValue.witClone; + return clone; + } +} + +/++ + ++/ +struct EnumData { + /++ + + +/ + WitString name; + + /++ + + +/ + WitList!(int) values; + + void witFree() @nogc nothrow { + name.witFree; + values.witFree; + } + + void witDrop() @nogc nothrow { + } + + EnumData witClone() const @nogc nothrow { + EnumData clone = void; + clone.name = this.name.witClone; + clone.values = this.values.witClone; + return clone; + } +} + +/++ + ++/ +struct ChainedSubcommandRelationship { + /++ + + +/ + int index; + + /++ + + +/ + int value; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ChainedSubcommandRelationship witClone() const @nogc nothrow { + ChainedSubcommandRelationship clone = void; + clone.index = this.index.witClone; + clone.value = this.value.witClone; + return clone; + } +} + +/++ + ++/ +struct ChainedSubcommandData { + /++ + + +/ + WitString name; + + /++ + + +/ + WitList!(ChainedSubcommandRelationship) subcommandValues; + + void witFree() @nogc nothrow { + name.witFree; + subcommandValues.witFree; + } + + void witDrop() @nogc nothrow { + } + + ChainedSubcommandData witClone() const @nogc nothrow { + ChainedSubcommandData clone = void; + clone.name = this.name.witClone; + clone.subcommandValues = this.subcommandValues.witClone; + return clone; + } +} + +/++ + ++/ +struct ParamData { + /++ + + +/ + WitString name; + + /++ + + +/ + int parseSymbol; + + /++ + + +/ + bool isOptional; + + /++ + + +/ + ubyte options; + + void witFree() @nogc nothrow { + name.witFree; + } + + void witDrop() @nogc nothrow { + } + + ParamData witClone() const @nogc nothrow { + ParamData clone = void; + clone.name = this.name.witClone; + clone.parseSymbol = this.parseSymbol.witClone; + clone.isOptional = this.isOptional.witClone; + clone.options = this.options.witClone; + return clone; + } +} + +/++ + ++/ +struct OverloadData { + /++ + + +/ + bool isChaining; + + /++ + + +/ + WitList!(ParamData) parameterData; + + void witFree() @nogc nothrow { + parameterData.witFree; + } + + void witDrop() @nogc nothrow { + } + + OverloadData witClone() const @nogc nothrow { + OverloadData clone = void; + clone.isChaining = this.isChaining.witClone; + clone.parameterData = this.parameterData.witClone; + return clone; + } +} + +/++ + ++/ +struct SoftEnumData { + /++ + + +/ + WitString enumName; + + /++ + + +/ + WitList!(WitString) enumOptions; + + void witFree() @nogc nothrow { + enumName.witFree; + enumOptions.witFree; + } + + void witDrop() @nogc nothrow { + } + + SoftEnumData witClone() const @nogc nothrow { + SoftEnumData clone = void; + clone.enumName = this.enumName.witClone; + clone.enumOptions = this.enumOptions.witClone; + return clone; + } +} + +/++ + ++/ +struct ConstrainedValueData { + /++ + + +/ + int enumValueSymbol; + + /++ + + +/ + int enumSymbol; + + /++ + + +/ + WitList!(ubyte) constraintIndices; + + void witFree() @nogc nothrow { + constraintIndices.witFree; + } + + void witDrop() @nogc nothrow { + } + + ConstrainedValueData witClone() const @nogc nothrow { + ConstrainedValueData clone = void; + clone.enumValueSymbol = this.enumValueSymbol.witClone; + clone.enumSymbol = this.enumSymbol.witClone; + clone.constraintIndices = this.constraintIndices.witClone; + return clone; + } +} + +/++ + ++/ +struct CBlockActorData { + /++ + + +/ + Tuple!(int, int, int) blockPosition; + + /++ + + +/ + WitString actorDataTags; + + void witFree() @nogc nothrow { + actorDataTags.witFree; + } + + void witDrop() @nogc nothrow { + } + + CBlockActorData witClone() const @nogc nothrow { + CBlockActorData clone = void; + clone.blockPosition = this.blockPosition.witClone; + clone.actorDataTags = this.actorDataTags.witClone; + return clone; + } +} + +/++ + ++/ +struct CBlockEvent { + /++ + + +/ + Tuple!(int, int, int) blockPosition; + + /++ + + +/ + int eventType; + + /++ + + +/ + int eventValue; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CBlockEvent witClone() const @nogc nothrow { + CBlockEvent clone = void; + clone.blockPosition = this.blockPosition.witClone; + clone.eventType = this.eventType.witClone; + clone.eventValue = this.eventValue.witClone; + return clone; + } +} + +/++ + ++/ +struct CBossEvent { + /++ + + +/ + long bossEntityId; + + /++ + + +/ + long playerEntityId; + + /++ + + +/ + ubyte eventType; + + /++ + + +/ + WitString title; + + /++ + + +/ + WitString filteredTitle; + + /++ + + +/ + float healthPercentage; + + /++ + + +/ + ubyte color; + + /++ + + +/ + ubyte overlay; + + void witFree() @nogc nothrow { + title.witFree; + filteredTitle.witFree; + } + + void witDrop() @nogc nothrow { + } + + CBossEvent witClone() const @nogc nothrow { + CBossEvent clone = void; + clone.bossEntityId = this.bossEntityId.witClone; + clone.playerEntityId = this.playerEntityId.witClone; + clone.eventType = this.eventType.witClone; + clone.title = this.title.witClone; + clone.filteredTitle = this.filteredTitle.witClone; + clone.healthPercentage = this.healthPercentage.witClone; + clone.color = this.color.witClone; + clone.overlay = this.overlay.witClone; + return clone; + } +} + +/++ + ++/ +struct CChangeDimension { + /++ + + +/ + int dimensionId; + + /++ + + +/ + Tuple!(double, double, double) position; + + /++ + + +/ + bool respawn; + + /++ + + +/ + Option!(int) loadingScreenId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CChangeDimension witClone() const @nogc nothrow { + CChangeDimension clone = void; + clone.dimensionId = this.dimensionId.witClone; + clone.position = this.position.witClone; + clone.respawn = this.respawn.witClone; + clone.loadingScreenId = this.loadingScreenId.witClone; + return clone; + } +} + +/++ + ++/ +struct CChunkRadiusUpdated { + /++ + + +/ + int chunkRadius; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CChunkRadiusUpdated witClone() const @nogc nothrow { + CChunkRadiusUpdated clone = void; + clone.chunkRadius = this.chunkRadius.witClone; + return clone; + } +} + +/++ + ++/ +struct MissingBlobData { + /++ + + +/ + long blobId; + + /++ + + +/ + WitList!(ubyte) blobData; + + void witFree() @nogc nothrow { + blobData.witFree; + } + + void witDrop() @nogc nothrow { + } + + MissingBlobData witClone() const @nogc nothrow { + MissingBlobData clone = void; + clone.blobId = this.blobId.witClone; + clone.blobData = this.blobData.witClone; + return clone; + } +} + +/++ + ++/ +struct CClientCacheMissResponse { + /++ + + +/ + WitList!(MissingBlobData) missingBlobs; + + void witFree() @nogc nothrow { + missingBlobs.witFree; + } + + void witDrop() @nogc nothrow { + } + + CClientCacheMissResponse witClone() const @nogc nothrow { + CClientCacheMissResponse clone = void; + clone.missingBlobs = this.missingBlobs.witClone; + return clone; + } +} + +/++ + ++/ +enum BuildPlatform : ubyte { + /++ + + +/ + unknown, + + /++ + + +/ + google, + + /++ + + +/ + ios, + + /++ + + +/ + osx, + + /++ + + +/ + amazon, + + /++ + + +/ + gearVr, + + /++ + + +/ + uwp, + + /++ + + +/ + win32, + + /++ + + +/ + dedicated, + + /++ + + +/ + tvOs, + + /++ + + +/ + sony, + + /++ + + +/ + nx, + + /++ + + +/ + xbox, + + /++ + + +/ + windowsPhone, + + /++ + + +/ + linux, +} +/++ + ++/ +enum GameType : ubyte { + /++ + + +/ + unknown, + + /++ + + +/ + survival, + + /++ + + +/ + creative, + + /++ + + +/ + adventure, + + /++ + + +/ + default_, + + /++ + + +/ + spectator, +} +/++ + ++/ +enum PlayerPermissionLevel : ubyte { + /++ + + +/ + visitor, + + /++ + + +/ + member, + + /++ + + +/ + operator, + + /++ + + +/ + custom, +} +/++ + ++/ +enum CommandPermissionLevel : ubyte { + /++ + + +/ + any, + + /++ + + +/ + gameDirectors, + + /++ + + +/ + admin, + + /++ + + +/ + host, + + /++ + + +/ + owner, + + /++ + + +/ + internal, +} +/++ + ++/ +struct CommandData { + /++ + + +/ + WitString name; + + /++ + + +/ + WitString description; + + /++ + + +/ + int flags; + + /++ + + +/ + CommandPermissionLevel permissionLevel; + + /++ + + +/ + int aliasEnum; + + /++ + + +/ + WitList!(int) commandDataChainedSubcommandIndexes; + + /++ + + +/ + WitList!(OverloadData) overloads; + + void witFree() @nogc nothrow { + name.witFree; + description.witFree; + commandDataChainedSubcommandIndexes.witFree; + overloads.witFree; + } + + void witDrop() @nogc nothrow { + } + + CommandData witClone() const @nogc nothrow { + CommandData clone = void; + clone.name = this.name.witClone; + clone.description = this.description.witClone; + clone.flags = this.flags.witClone; + clone.permissionLevel = this.permissionLevel.witClone; + clone.aliasEnum = this.aliasEnum.witClone; + clone.commandDataChainedSubcommandIndexes = this.commandDataChainedSubcommandIndexes.witClone; + clone.overloads = this.overloads.witClone; + return clone; + } +} + +/++ + ++/ +struct CAvailableCommands { + /++ + + +/ + WitList!(WitString) enumValues; + + /++ + + +/ + WitList!(WitString) chainedSubcommandValues; + + /++ + + +/ + WitList!(WitString) postFixes; + + /++ + + +/ + WitList!(EnumData) enumData; + + /++ + + +/ + WitList!(ChainedSubcommandData) chainedSubcommandData; + + /++ + + +/ + WitList!(CommandData) commands; + + /++ + + +/ + WitList!(SoftEnumData) softEnums; + + /++ + + +/ + WitList!(ConstrainedValueData) constraints; + + void witFree() @nogc nothrow { + enumValues.witFree; + chainedSubcommandValues.witFree; + postFixes.witFree; + enumData.witFree; + chainedSubcommandData.witFree; + commands.witFree; + softEnums.witFree; + constraints.witFree; + } + + void witDrop() @nogc nothrow { + } + + CAvailableCommands witClone() const @nogc nothrow { + CAvailableCommands clone = void; + clone.enumValues = this.enumValues.witClone; + clone.chainedSubcommandValues = this.chainedSubcommandValues.witClone; + clone.postFixes = this.postFixes.witClone; + clone.enumData = this.enumData.witClone; + clone.chainedSubcommandData = this.chainedSubcommandData.witClone; + clone.commands = this.commands.witClone; + clone.softEnums = this.softEnums.witClone; + clone.constraints = this.constraints.witClone; + return clone; + } +} + +/++ + ++/ +struct SerializedAbilitiesDataSerializedLayer { + /++ + + +/ + int serializedLayer; + + /++ + + +/ + int abilitiesSet; + + /++ + + +/ + int abilityValue; + + /++ + + +/ + float flySpeed; + + /++ + + +/ + float verticalFlySpeed; + + /++ + + +/ + float walkSpeed; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SerializedAbilitiesDataSerializedLayer witClone() const @nogc nothrow { + SerializedAbilitiesDataSerializedLayer clone = void; + clone.serializedLayer = this.serializedLayer.witClone; + clone.abilitiesSet = this.abilitiesSet.witClone; + clone.abilityValue = this.abilityValue.witClone; + clone.flySpeed = this.flySpeed.witClone; + clone.verticalFlySpeed = this.verticalFlySpeed.witClone; + clone.walkSpeed = this.walkSpeed.witClone; + return clone; + } +} + +/++ + ++/ +struct SerializedAbilitiesData { + /++ + + +/ + long targetPlayerRawId; + + /++ + + +/ + PlayerPermissionLevel playerPermissions; + + /++ + + +/ + CommandPermissionLevel commandPermissions; + + /++ + + +/ + WitList!(SerializedAbilitiesDataSerializedLayer) layers; + + void witFree() @nogc nothrow { + layers.witFree; + } + + void witDrop() @nogc nothrow { + } + + SerializedAbilitiesData witClone() const @nogc nothrow { + SerializedAbilitiesData clone = void; + clone.targetPlayerRawId = this.targetPlayerRawId.witClone; + clone.playerPermissions = this.playerPermissions.witClone; + clone.commandPermissions = this.commandPermissions.witClone; + clone.layers = this.layers.witClone; + return clone; + } +} + +/++ + ++/ +struct ActorLink { + /++ + + +/ + long riddenUniqueId; + + /++ + + +/ + long riderUniqueId; + + /++ + + +/ + ubyte linkType; + + /++ + + +/ + bool immediate; + + /++ + + +/ + bool riderInitiated; + + /++ + + +/ + float vehicleAngularVelocity; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ActorLink witClone() const @nogc nothrow { + ActorLink clone = void; + clone.riddenUniqueId = this.riddenUniqueId.witClone; + clone.riderUniqueId = this.riderUniqueId.witClone; + clone.linkType = this.linkType.witClone; + clone.immediate = this.immediate.witClone; + clone.riderInitiated = this.riderInitiated.witClone; + clone.vehicleAngularVelocity = this.vehicleAngularVelocity.witClone; + return clone; + } +} + +/++ + ++/ +struct CContainerOpen { + /++ + + +/ + ubyte containerId; + + /++ + + +/ + ubyte containerType; + + /++ + + +/ + Tuple!(int, int, int) position; + + /++ + + +/ + long targetEntityId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CContainerOpen witClone() const @nogc nothrow { + CContainerOpen clone = void; + clone.containerId = this.containerId.witClone; + clone.containerType = this.containerType.witClone; + clone.position = this.position.witClone; + clone.targetEntityId = this.targetEntityId.witClone; + return clone; + } +} + +/++ + ++/ +struct CCorrectPlayerMovePrediction { + /++ + + +/ + ubyte predictionType; + + /++ + + +/ + Tuple!(double, double, double) pos; + + /++ + + +/ + Tuple!(double, double, double) posDelta; + + /++ + + +/ + Tuple!(double, double) rotation; + + /++ + + +/ + Option!(float) vehicleAngularVelocity; + + /++ + + +/ + bool onGround; + + /++ + + +/ + long tick; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CCorrectPlayerMovePrediction witClone() const @nogc nothrow { + CCorrectPlayerMovePrediction clone = void; + clone.predictionType = this.predictionType.witClone; + clone.pos = this.pos.witClone; + clone.posDelta = this.posDelta.witClone; + clone.rotation = this.rotation.witClone; + clone.vehicleAngularVelocity = this.vehicleAngularVelocity.witClone; + clone.onGround = this.onGround.witClone; + clone.tick = this.tick.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemDescriptorCount { + /++ + + +/ + WitString itemIdentifier; + + /++ + + +/ + int metadataValue; + + /++ + + +/ + int count; + + void witFree() @nogc nothrow { + itemIdentifier.witFree; + } + + void witDrop() @nogc nothrow { + } + + ItemDescriptorCount witClone() const @nogc nothrow { + ItemDescriptorCount clone = void; + clone.itemIdentifier = this.itemIdentifier.witClone; + clone.metadataValue = this.metadataValue.witClone; + clone.count = this.count.witClone; + return clone; + } +} + +/++ + ++/ +struct RecipeUnlockRequirement { + /++ + + +/ + int context; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + RecipeUnlockRequirement witClone() const @nogc nothrow { + RecipeUnlockRequirement clone = void; + clone.context = this.context.witClone; + return clone; + } +} + +/++ + ++/ +enum CreativeCategory : ubyte { + /++ + + +/ + all, + + /++ + + +/ + construction, + + /++ + + +/ + nature, + + /++ + + +/ + equipment, + + /++ + + +/ + items, + + /++ + + +/ + itemCommandOnly, + + /++ + + +/ + undefined, +} +/++ + ++/ +struct CDisconnect { + /++ + + +/ + int reason; + + /++ + + +/ + bool skipMessage; + + /++ + + +/ + WitString message; + + /++ + + +/ + WitString filteredMessage; + + void witFree() @nogc nothrow { + message.witFree; + filteredMessage.witFree; + } + + void witDrop() @nogc nothrow { + } + + CDisconnect witClone() const @nogc nothrow { + CDisconnect clone = void; + clone.reason = this.reason.witClone; + clone.skipMessage = this.skipMessage.witClone; + clone.message = this.message.witClone; + clone.filteredMessage = this.filteredMessage.witClone; + return clone; + } +} + +/++ + ++/ +enum RuleValue : ubyte { + /++ + + +/ + null_, +} +/++ + ++/ +struct GameRule { + /++ + + +/ + WitString ruleName; + + /++ + + +/ + bool ruleCanBeModified; + + /++ + + +/ + RuleValue ruleValue; + + void witFree() @nogc nothrow { + ruleName.witFree; + } + + void witDrop() @nogc nothrow { + } + + GameRule witClone() const @nogc nothrow { + GameRule clone = void; + clone.ruleName = this.ruleName.witClone; + clone.ruleCanBeModified = this.ruleCanBeModified.witClone; + clone.ruleValue = this.ruleValue.witClone; + return clone; + } +} + +/++ + ++/ +struct CGamerulesChanged { + /++ + + +/ + WitList!(GameRule) ruleData; + + void witFree() @nogc nothrow { + ruleData.witFree; + } + + void witDrop() @nogc nothrow { + } + + CGamerulesChanged witClone() const @nogc nothrow { + CGamerulesChanged clone = void; + clone.ruleData = this.ruleData.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemData { + /++ + + +/ + WitString itemName; + + /++ + + +/ + int itemId; + + /++ + + +/ + bool isComponentBased; + + /++ + + +/ + int itemVersion; + + /++ + + +/ + WitList!(ubyte) componentData; + + void witFree() @nogc nothrow { + itemName.witFree; + componentData.witFree; + } + + void witDrop() @nogc nothrow { + } + + ItemData witClone() const @nogc nothrow { + ItemData clone = void; + clone.itemName = this.itemName.witClone; + clone.itemId = this.itemId.witClone; + clone.isComponentBased = this.isComponentBased.witClone; + clone.itemVersion = this.itemVersion.witClone; + clone.componentData = this.componentData.witClone; + return clone; + } +} + +/++ + ++/ +struct CItemRegistry { + /++ + + +/ + WitList!(ItemData) items; + + void witFree() @nogc nothrow { + items.witFree; + } + + void witDrop() @nogc nothrow { + } + + CItemRegistry witClone() const @nogc nothrow { + CItemRegistry clone = void; + clone.items = this.items.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemStackResponseSlotInfo { + /++ + + +/ + ubyte requestedSlot; + + /++ + + +/ + ubyte slot; + + /++ + + +/ + ubyte amount; + + /++ + + +/ + int itemStackNetId; + + /++ + + +/ + WitString customName; + + /++ + + +/ + WitString filteredCustomName; + + /++ + + +/ + int durabilityCorrection; + + void witFree() @nogc nothrow { + customName.witFree; + filteredCustomName.witFree; + } + + void witDrop() @nogc nothrow { + } + + ItemStackResponseSlotInfo witClone() const @nogc nothrow { + ItemStackResponseSlotInfo clone = void; + clone.requestedSlot = this.requestedSlot.witClone; + clone.slot = this.slot.witClone; + clone.amount = this.amount.witClone; + clone.itemStackNetId = this.itemStackNetId.witClone; + clone.customName = this.customName.witClone; + clone.filteredCustomName = this.filteredCustomName.witClone; + clone.durabilityCorrection = this.durabilityCorrection.witClone; + return clone; + } +} + +/++ + ++/ +struct CLevelChunk { + /++ + + +/ + int dimension; + + /++ + + +/ + bool cacheEnabled; + + /++ + + +/ + WitList!(ubyte) chunk; + + /++ + + +/ + WitList!(WitString) blockActors; + + void witFree() @nogc nothrow { + chunk.witFree; + blockActors.witFree; + } + + void witDrop() @nogc nothrow { + } + + CLevelChunk witClone() const @nogc nothrow { + CLevelChunk clone = void; + clone.dimension = this.dimension.witClone; + clone.cacheEnabled = this.cacheEnabled.witClone; + clone.chunk = this.chunk.witClone; + clone.blockActors = this.blockActors.witClone; + return clone; + } +} + +/++ + ++/ +struct CLevelEvent { + /++ + + +/ + int eventId; + + /++ + + +/ + Tuple!(double, double, double) position; + + /++ + + +/ + int data; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CLevelEvent witClone() const @nogc nothrow { + CLevelEvent clone = void; + clone.eventId = this.eventId.witClone; + clone.position = this.position.witClone; + clone.data = this.data.witClone; + return clone; + } +} + +/++ + ++/ +enum LevelEvent : ubyte { + /++ + + +/ + particlesDestroyBlock, + + /++ + + +/ + blockStartBreak, + + /++ + + +/ + blockStopBreak, + + /++ + + +/ + blockUpdateBreak, +} +/++ + ++/ +struct CLevelSoundEvent { + /++ + + +/ + WitString soundEvent; + + /++ + + +/ + Tuple!(double, double, double) position; + + /++ + + +/ + int data; + + /++ + + +/ + WitString actorIdentifier; + + /++ + + +/ + bool isBaby; + + /++ + + +/ + bool isGlobal; + + /++ + + +/ + long actorUniqueId; + + /++ + + +/ + Option!(Tuple!(double, double, double)) fireAtPosition; + + void witFree() @nogc nothrow { + soundEvent.witFree; + actorIdentifier.witFree; + } + + void witDrop() @nogc nothrow { + } + + CLevelSoundEvent witClone() const @nogc nothrow { + CLevelSoundEvent clone = void; + clone.soundEvent = this.soundEvent.witClone; + clone.position = this.position.witClone; + clone.data = this.data.witClone; + clone.actorIdentifier = this.actorIdentifier.witClone; + clone.isBaby = this.isBaby.witClone; + clone.isGlobal = this.isGlobal.witClone; + clone.actorUniqueId = this.actorUniqueId.witClone; + clone.fireAtPosition = this.fireAtPosition.witClone; + return clone; + } +} + +/++ + ++/ +struct CMobEffect { + /++ + + +/ + long targetRuntimeId; + + /++ + + +/ + ubyte eventId; + + /++ + + +/ + int effectId; + + /++ + + +/ + int effectAmplifier; + + /++ + + +/ + bool showParticles; + + /++ + + +/ + int effectDurationTicks; + + /++ + + +/ + long tick; + + /++ + + +/ + bool ambient; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CMobEffect witClone() const @nogc nothrow { + CMobEffect clone = void; + clone.targetRuntimeId = this.targetRuntimeId.witClone; + clone.eventId = this.eventId.witClone; + clone.effectId = this.effectId.witClone; + clone.effectAmplifier = this.effectAmplifier.witClone; + clone.showParticles = this.showParticles.witClone; + clone.effectDurationTicks = this.effectDurationTicks.witClone; + clone.tick = this.tick.witClone; + clone.ambient = this.ambient.witClone; + return clone; + } +} + +/++ + ++/ +struct CModalFormRequest { + /++ + + +/ + int formId; + + /++ + + +/ + WitString formUiJson; + + void witFree() @nogc nothrow { + formUiJson.witFree; + } + + void witDrop() @nogc nothrow { + } + + CModalFormRequest witClone() const @nogc nothrow { + CModalFormRequest clone = void; + clone.formId = this.formId.witClone; + clone.formUiJson = this.formUiJson.witClone; + return clone; + } +} + +/++ + ++/ +struct CMoveActorAbsolute { + /++ + + +/ + long actorRuntimeId; + + /++ + + +/ + ubyte header; + + /++ + + +/ + Tuple!(double, double, double) position; + + /++ + + +/ + ubyte rotationX; + + /++ + + +/ + ubyte rotationY; + + /++ + + +/ + ubyte rotationYHead; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CMoveActorAbsolute witClone() const @nogc nothrow { + CMoveActorAbsolute clone = void; + clone.actorRuntimeId = this.actorRuntimeId.witClone; + clone.header = this.header.witClone; + clone.position = this.position.witClone; + clone.rotationX = this.rotationX.witClone; + clone.rotationY = this.rotationY.witClone; + clone.rotationYHead = this.rotationYHead.witClone; + return clone; + } +} + +/++ + ++/ +struct CMoveActorDelta { + /++ + + +/ + long entityRuntimeId; + + /++ + + +/ + int flags; + + /++ + + +/ + float x; + + /++ + + +/ + float y; + + /++ + + +/ + float z; + + /++ + + +/ + ubyte pitch; + + /++ + + +/ + ubyte yaw; + + /++ + + +/ + ubyte headYaw; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CMoveActorDelta witClone() const @nogc nothrow { + CMoveActorDelta clone = void; + clone.entityRuntimeId = this.entityRuntimeId.witClone; + clone.flags = this.flags.witClone; + clone.x = this.x.witClone; + clone.y = this.y.witClone; + clone.z = this.z.witClone; + clone.pitch = this.pitch.witClone; + clone.yaw = this.yaw.witClone; + clone.headYaw = this.headYaw.witClone; + return clone; + } +} + +/++ + ++/ +struct CMovePlayer { + /++ + + +/ + long playerRuntimeId; + + /++ + + +/ + Tuple!(double, double, double) position; + + /++ + + +/ + float pitch; + + /++ + + +/ + float yaw; + + /++ + + +/ + float headYaw; + + /++ + + +/ + ubyte mode; + + /++ + + +/ + bool onGround; + + /++ + + +/ + long ridingRuntimeId; + + /++ + + +/ + int teleportCause; + + /++ + + +/ + int teleportSourceEntityType; + + /++ + + +/ + long tick; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CMovePlayer witClone() const @nogc nothrow { + CMovePlayer clone = void; + clone.playerRuntimeId = this.playerRuntimeId.witClone; + clone.position = this.position.witClone; + clone.pitch = this.pitch.witClone; + clone.yaw = this.yaw.witClone; + clone.headYaw = this.headYaw.witClone; + clone.mode = this.mode.witClone; + clone.onGround = this.onGround.witClone; + clone.ridingRuntimeId = this.ridingRuntimeId.witClone; + clone.teleportCause = this.teleportCause.witClone; + clone.teleportSourceEntityType = this.teleportSourceEntityType.witClone; + clone.tick = this.tick.witClone; + return clone; + } +} + +/++ + ++/ +struct CNetworkChunkPublisherUpdate { + /++ + + +/ + Tuple!(int, int, int) posForView; + + /++ + + +/ + int newRadius; + + /++ + + +/ + WitList!(Tuple!(double, double)) serverBuildChunkList; + + void witFree() @nogc nothrow { + serverBuildChunkList.witFree; + } + + void witDrop() @nogc nothrow { + } + + CNetworkChunkPublisherUpdate witClone() const @nogc nothrow { + CNetworkChunkPublisherUpdate clone = void; + clone.posForView = this.posForView.witClone; + clone.newRadius = this.newRadius.witClone; + clone.serverBuildChunkList = this.serverBuildChunkList.witClone; + return clone; + } +} + +/++ + ++/ +struct CNetworkSettings { + /++ + + +/ + int compressionThreshold; + + /++ + + +/ + int compressionAlgorithm; + + /++ + + +/ + bool clientThrottleEnabled; + + /++ + + +/ + ubyte clientThrottleThreshold; + + /++ + + +/ + float clientThrottleScalar; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CNetworkSettings witClone() const @nogc nothrow { + CNetworkSettings clone = void; + clone.compressionThreshold = this.compressionThreshold.witClone; + clone.compressionAlgorithm = this.compressionAlgorithm.witClone; + clone.clientThrottleEnabled = this.clientThrottleEnabled.witClone; + clone.clientThrottleThreshold = this.clientThrottleThreshold.witClone; + clone.clientThrottleScalar = this.clientThrottleScalar.witClone; + return clone; + } +} + +/++ + ++/ +enum CPlayStatus : ubyte { + /++ + + +/ + loginSuccess, + + /++ + + +/ + outdatedClient, + + /++ + + +/ + outdatedServer, + + /++ + + +/ + playerSpawn, + + /++ + + +/ + invalidTenant, + + /++ + + +/ + editionMismatchEduToVanilla, + + /++ + + +/ + editionMismatchVanillaToEdu, + + /++ + + +/ + serverFullSubClient, + + /++ + + +/ + editorMismatchEditorToVanilla, + + /++ + + +/ + editorMismatchVanillaToEditor, +} +/++ + ++/ +struct CPlayerHotbar { + /++ + + +/ + int selectedSlot; + + /++ + + +/ + ubyte containerId; + + /++ + + +/ + bool shouldSelectSlot; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CPlayerHotbar witClone() const @nogc nothrow { + CPlayerHotbar clone = void; + clone.selectedSlot = this.selectedSlot.witClone; + clone.containerId = this.containerId.witClone; + clone.shouldSelectSlot = this.shouldSelectSlot.witClone; + return clone; + } +} + +/++ + ++/ +struct PieceTintColor { + /++ + + +/ + WitString pieceType; + + /++ + + +/ + WitList!(int) colors; + + void witFree() @nogc nothrow { + pieceType.witFree; + colors.witFree; + } + + void witDrop() @nogc nothrow { + } + + PieceTintColor witClone() const @nogc nothrow { + PieceTintColor clone = void; + clone.pieceType = this.pieceType.witClone; + clone.colors = this.colors.witClone; + return clone; + } +} + +/++ + ++/ +struct Skin { + /++ + + +/ + WitString skinId; + + /++ + + +/ + WitString playFabId; + + /++ + + +/ + WitList!(ubyte) resourcePatch; + + /++ + + +/ + int imageWidth; + + /++ + + +/ + int imageHeight; + + /++ + + +/ + WitList!(ubyte) skinData; + + /++ + + +/ + WitList!(SkinAnimation) animations; + + /++ + + +/ + int capeWidth; + + /++ + + +/ + int capeHeight; + + /++ + + +/ + WitList!(ubyte) capeData; + + /++ + + +/ + WitList!(ubyte) geometryData; + + /++ + + +/ + WitList!(ubyte) animationData; + + /++ + + +/ + WitList!(ubyte) geometryDataEngineVersion; + + /++ + + +/ + WitString capeId; + + /++ + + +/ + WitString fullId; + + /++ + + +/ + WitString armSize; + + /++ + + +/ + WitString skinColor; + + /++ + + +/ + WitList!(PersonaPiece) personaPieces; + + /++ + + +/ + WitList!(PieceTintColor) pieceTintColors; + + /++ + + +/ + bool isPremium; + + /++ + + +/ + bool isPersona; + + /++ + + +/ + bool personaCapeOnClassic; + + /++ + + +/ + bool isPrimaryUser; + + /++ + + +/ + bool overrideAppearance; + + /++ + + +/ + bool isTrusted; + + /++ + + +/ + WitString profileHash; + + void witFree() @nogc nothrow { + skinId.witFree; + playFabId.witFree; + resourcePatch.witFree; + skinData.witFree; + animations.witFree; + capeData.witFree; + geometryData.witFree; + animationData.witFree; + geometryDataEngineVersion.witFree; + capeId.witFree; + fullId.witFree; + armSize.witFree; + skinColor.witFree; + personaPieces.witFree; + pieceTintColors.witFree; + profileHash.witFree; + } + + void witDrop() @nogc nothrow { + } + + Skin witClone() const @nogc nothrow { + Skin clone = void; + clone.skinId = this.skinId.witClone; + clone.playFabId = this.playFabId.witClone; + clone.resourcePatch = this.resourcePatch.witClone; + clone.imageWidth = this.imageWidth.witClone; + clone.imageHeight = this.imageHeight.witClone; + clone.skinData = this.skinData.witClone; + clone.animations = this.animations.witClone; + clone.capeWidth = this.capeWidth.witClone; + clone.capeHeight = this.capeHeight.witClone; + clone.capeData = this.capeData.witClone; + clone.geometryData = this.geometryData.witClone; + clone.animationData = this.animationData.witClone; + clone.geometryDataEngineVersion = this.geometryDataEngineVersion.witClone; + clone.capeId = this.capeId.witClone; + clone.fullId = this.fullId.witClone; + clone.armSize = this.armSize.witClone; + clone.skinColor = this.skinColor.witClone; + clone.personaPieces = this.personaPieces.witClone; + clone.pieceTintColors = this.pieceTintColors.witClone; + clone.isPremium = this.isPremium.witClone; + clone.isPersona = this.isPersona.witClone; + clone.personaCapeOnClassic = this.personaCapeOnClassic.witClone; + clone.isPrimaryUser = this.isPrimaryUser.witClone; + clone.overrideAppearance = this.overrideAppearance.witClone; + clone.isTrusted = this.isTrusted.witClone; + clone.profileHash = this.profileHash.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerListEntry { + /++ + + +/ + Uuid uuid; + + /++ + + +/ + long entityUniqueId; + + /++ + + +/ + WitString username; + + /++ + + +/ + WitString xuid; + + /++ + + +/ + WitString platformChatId; + + /++ + + +/ + BuildPlatform buildPlatform; + + /++ + + +/ + Skin skin; + + /++ + + +/ + bool isTeacher; + + /++ + + +/ + bool isHost; + + /++ + + +/ + bool isSubClient; + + /++ + + +/ + WitList!(ubyte) playerColor; + + void witFree() @nogc nothrow { + username.witFree; + xuid.witFree; + platformChatId.witFree; + skin.witFree; + playerColor.witFree; + } + + void witDrop() @nogc nothrow { + } + + PlayerListEntry witClone() const @nogc nothrow { + PlayerListEntry clone = void; + clone.uuid = this.uuid.witClone; + clone.entityUniqueId = this.entityUniqueId.witClone; + clone.username = this.username.witClone; + clone.xuid = this.xuid.witClone; + clone.platformChatId = this.platformChatId.witClone; + clone.buildPlatform = this.buildPlatform.witClone; + clone.skin = this.skin.witClone; + clone.isTeacher = this.isTeacher.witClone; + clone.isHost = this.isHost.witClone; + clone.isSubClient = this.isSubClient.witClone; + clone.playerColor = this.playerColor.witClone; + return clone; + } +} + +/++ + ++/ +struct CPlayerList { + /++ + + +/ + ubyte action; + + /++ + + +/ + WitList!(PlayerListEntry) entries; + + void witFree() @nogc nothrow { + entries.witFree; + } + + void witDrop() @nogc nothrow { + } + + CPlayerList witClone() const @nogc nothrow { + CPlayerList clone = void; + clone.action = this.action.witClone; + clone.entries = this.entries.witClone; + return clone; + } +} + +/++ + ++/ +struct CRemoveActor { + /++ + + +/ + long targetActorId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CRemoveActor witClone() const @nogc nothrow { + CRemoveActor clone = void; + clone.targetActorId = this.targetActorId.witClone; + return clone; + } +} + +/++ + ++/ +struct CRemoveObjective { + /++ + + +/ + WitString objectiveName; + + void witFree() @nogc nothrow { + objectiveName.witFree; + } + + void witDrop() @nogc nothrow { + } + + CRemoveObjective witClone() const @nogc nothrow { + CRemoveObjective clone = void; + clone.objectiveName = this.objectiveName.witClone; + return clone; + } +} + +/++ + ++/ +struct PackInstanceId { + /++ + + +/ + WitString packId; + + /++ + + +/ + WitString version_; + + /++ + + +/ + WitString subPackName; + + void witFree() @nogc nothrow { + packId.witFree; + version_.witFree; + subPackName.witFree; + } + + void witDrop() @nogc nothrow { + } + + PackInstanceId witClone() const @nogc nothrow { + PackInstanceId clone = void; + clone.packId = this.packId.witClone; + clone.version_ = this.version_.witClone; + clone.subPackName = this.subPackName.witClone; + return clone; + } +} + +/++ + ++/ +struct PackIdVersion { + /++ + + +/ + Uuid packUuid; + + /++ + + +/ + WitString packVersion; + + void witFree() @nogc nothrow { + packVersion.witFree; + } + + void witDrop() @nogc nothrow { + } + + PackIdVersion witClone() const @nogc nothrow { + PackIdVersion clone = void; + clone.packUuid = this.packUuid.witClone; + clone.packVersion = this.packVersion.witClone; + return clone; + } +} + +/++ + ++/ +struct PackInfoData { + /++ + + +/ + PackIdVersion packIdVersion; + + /++ + + +/ + long packSize; + + /++ + + +/ + WitString contentKey; + + /++ + + +/ + WitString subpackName; + + /++ + + +/ + WitString contentIdentity; + + /++ + + +/ + bool hasScripts; + + /++ + + +/ + bool isAddonPack; + + /++ + + +/ + bool isRayTracingCapable; + + /++ + + +/ + WitString cdnUrl; + + void witFree() @nogc nothrow { + packIdVersion.witFree; + contentKey.witFree; + subpackName.witFree; + contentIdentity.witFree; + cdnUrl.witFree; + } + + void witDrop() @nogc nothrow { + } + + PackInfoData witClone() const @nogc nothrow { + PackInfoData clone = void; + clone.packIdVersion = this.packIdVersion.witClone; + clone.packSize = this.packSize.witClone; + clone.contentKey = this.contentKey.witClone; + clone.subpackName = this.subpackName.witClone; + clone.contentIdentity = this.contentIdentity.witClone; + clone.hasScripts = this.hasScripts.witClone; + clone.isAddonPack = this.isAddonPack.witClone; + clone.isRayTracingCapable = this.isRayTracingCapable.witClone; + clone.cdnUrl = this.cdnUrl.witClone; + return clone; + } +} + +/++ + ++/ +struct CResourcePacksInfo { + /++ + + +/ + bool resourcePackRequired; + + /++ + + +/ + bool hasAddonPacks; + + /++ + + +/ + bool hasScripts; + + /++ + + +/ + bool forceDisableVibrantVisuals; + + /++ + + +/ + PackIdVersion worldTemplateIdAndVersion; + + /++ + + +/ + WitList!(PackInfoData) resourcePacks; + + void witFree() @nogc nothrow { + worldTemplateIdAndVersion.witFree; + resourcePacks.witFree; + } + + void witDrop() @nogc nothrow { + } + + CResourcePacksInfo witClone() const @nogc nothrow { + CResourcePacksInfo clone = void; + clone.resourcePackRequired = this.resourcePackRequired.witClone; + clone.hasAddonPacks = this.hasAddonPacks.witClone; + clone.hasScripts = this.hasScripts.witClone; + clone.forceDisableVibrantVisuals = this.forceDisableVibrantVisuals.witClone; + clone.worldTemplateIdAndVersion = this.worldTemplateIdAndVersion.witClone; + clone.resourcePacks = this.resourcePacks.witClone; + return clone; + } +} + +/++ + ++/ +struct MetadataValue { + mixin WitVariant!( + ubyte, // byte_ + int, // short_ + int, // int_ + float, // float_ + WitString, // string + void, // compoundTag + Tuple!(int, int, int), // itemPos + long, // int64 + Tuple!(double, double, double), // vec3 + ); + +public: + enum Tag : ubyte { + /++ + + +/ + byte_, + + /++ + + +/ + short_, + + /++ + + +/ + int_, + + /++ + + +/ + float_, + + /++ + + +/ + string, + + /++ + + +/ + compoundTag, + + /++ + + +/ + itemPos, + + /++ + + +/ + int64, + + /++ + + +/ + vec3, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias byte_ = _create!(Tag.byte_); + /// ditto + pragma(inline, true) bool isByte() const => _tag == Tag.byte_; + ///ditto + alias getByte = _get!(Tag.byte_); + + /++ + + +/ + alias short_ = _create!(Tag.short_); + /// ditto + pragma(inline, true) bool isShort() const => _tag == Tag.short_; + ///ditto + alias getShort = _get!(Tag.short_); + + /++ + + +/ + alias int_ = _create!(Tag.int_); + /// ditto + pragma(inline, true) bool isInt() const => _tag == Tag.int_; + ///ditto + alias getInt = _get!(Tag.int_); + + /++ + + +/ + alias float_ = _create!(Tag.float_); + /// ditto + pragma(inline, true) bool isFloat() const => _tag == Tag.float_; + ///ditto + alias getFloat = _get!(Tag.float_); + + /++ + + +/ + alias string = _create!(Tag.string); + /// ditto + pragma(inline, true) bool isString() const => _tag == Tag.string; + ///ditto + alias getString = _get!(Tag.string); + + /++ + + +/ + alias compoundTag = _create!(Tag.compoundTag); + /// ditto + pragma(inline, true) bool isCompoundTag() const => _tag == Tag.compoundTag; + + /++ + + +/ + alias itemPos = _create!(Tag.itemPos); + /// ditto + pragma(inline, true) bool isItemPos() const => _tag == Tag.itemPos; + ///ditto + alias getItemPos = _get!(Tag.itemPos); + + /++ + + +/ + alias int64 = _create!(Tag.int64); + /// ditto + pragma(inline, true) bool isInt64() const => _tag == Tag.int64; + ///ditto + alias getInt64 = _get!(Tag.int64); + + /++ + + +/ + alias vec3 = _create!(Tag.vec3); + /// ditto + pragma(inline, true) bool isVec3() const => _tag == Tag.vec3; + ///ditto + alias getVec3 = _get!(Tag.vec3); + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case string: _get!(Tag.string).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + } + + MetadataValue witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.byte_: return _create!(Tag.byte_)(this._get!(Tag.byte_).witClone); break; + case Tag.short_: return _create!(Tag.short_)(this._get!(Tag.short_).witClone); break; + case Tag.int_: return _create!(Tag.int_)(this._get!(Tag.int_).witClone); break; + case Tag.float_: return _create!(Tag.float_)(this._get!(Tag.float_).witClone); break; + case Tag.string: return _create!(Tag.string)(this._get!(Tag.string).witClone); break; + case Tag.compoundTag: return _create!(Tag.compoundTag); break; + case Tag.itemPos: return _create!(Tag.itemPos)(this._get!(Tag.itemPos).witClone); break; + case Tag.int64: return _create!(Tag.int64)(this._get!(Tag.int64).witClone); break; + case Tag.vec3: return _create!(Tag.vec3)(this._get!(Tag.vec3).witClone); break; + } + } +} + +/++ + ++/ +struct PropertySyncData { + /++ + + +/ + WitList!(Tuple!(int, int)) intEntriesList; + + /++ + + +/ + WitList!(Tuple!(int, float)) floatEntriesList; + + void witFree() @nogc nothrow { + intEntriesList.witFree; + floatEntriesList.witFree; + } + + void witDrop() @nogc nothrow { + } + + PropertySyncData witClone() const @nogc nothrow { + PropertySyncData clone = void; + clone.intEntriesList = this.intEntriesList.witClone; + clone.floatEntriesList = this.floatEntriesList.witClone; + return clone; + } +} + +/++ + ++/ +struct CAddActor { + /++ + + +/ + long targetActorId; + + /++ + + +/ + long targetRuntimeId; + + /++ + + +/ + WitString actorType; + + /++ + + +/ + Tuple!(double, double, double) position; + + /++ + + +/ + Tuple!(double, double, double) velocity; + + /++ + + +/ + Tuple!(double, double) rotation; + + /++ + + +/ + float yHeadRotation; + + /++ + + +/ + float yBodyRotation; + + /++ + + +/ + WitList!(SyncedAttribute) attributesList; + + /++ + + +/ + WitString actorData; + + /++ + + +/ + PropertySyncData syncedProperties; + + /++ + + +/ + WitList!(ActorLink) actorLinks; + + void witFree() @nogc nothrow { + actorType.witFree; + attributesList.witFree; + actorData.witFree; + syncedProperties.witFree; + actorLinks.witFree; + } + + void witDrop() @nogc nothrow { + } + + CAddActor witClone() const @nogc nothrow { + CAddActor clone = void; + clone.targetActorId = this.targetActorId.witClone; + clone.targetRuntimeId = this.targetRuntimeId.witClone; + clone.actorType = this.actorType.witClone; + clone.position = this.position.witClone; + clone.velocity = this.velocity.witClone; + clone.rotation = this.rotation.witClone; + clone.yHeadRotation = this.yHeadRotation.witClone; + clone.yBodyRotation = this.yBodyRotation.witClone; + clone.attributesList = this.attributesList.witClone; + clone.actorData = this.actorData.witClone; + clone.syncedProperties = this.syncedProperties.witClone; + clone.actorLinks = this.actorLinks.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetActorData { + /++ + + +/ + long targetRuntimeId; + + /++ + + +/ + WitString actorData; + + /++ + + +/ + PropertySyncData syncedProperties; + + /++ + + +/ + long tick; + + void witFree() @nogc nothrow { + actorData.witFree; + syncedProperties.witFree; + } + + void witDrop() @nogc nothrow { + } + + CSetActorData witClone() const @nogc nothrow { + CSetActorData clone = void; + clone.targetRuntimeId = this.targetRuntimeId.witClone; + clone.actorData = this.actorData.witClone; + clone.syncedProperties = this.syncedProperties.witClone; + clone.tick = this.tick.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetActorLink { + /++ + + +/ + ActorLink link; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CSetActorLink witClone() const @nogc nothrow { + CSetActorLink clone = void; + clone.link = this.link.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetActorMotion { + /++ + + +/ + long targetRuntimeId; + + /++ + + +/ + Tuple!(double, double, double) motion; + + /++ + + +/ + long tick; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CSetActorMotion witClone() const @nogc nothrow { + CSetActorMotion clone = void; + clone.targetRuntimeId = this.targetRuntimeId.witClone; + clone.motion = this.motion.witClone; + clone.tick = this.tick.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetDifficulty { + /++ + + +/ + int difficulty; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CSetDifficulty witClone() const @nogc nothrow { + CSetDifficulty clone = void; + clone.difficulty = this.difficulty.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetDisplayObjective { + /++ + + +/ + WitString displaySlotName; + + /++ + + +/ + WitString objectiveName; + + /++ + + +/ + WitString objectiveDisplayName; + + /++ + + +/ + WitString criteriaName; + + /++ + + +/ + int sortOrder; + + void witFree() @nogc nothrow { + displaySlotName.witFree; + objectiveName.witFree; + objectiveDisplayName.witFree; + criteriaName.witFree; + } + + void witDrop() @nogc nothrow { + } + + CSetDisplayObjective witClone() const @nogc nothrow { + CSetDisplayObjective clone = void; + clone.displaySlotName = this.displaySlotName.witClone; + clone.objectiveName = this.objectiveName.witClone; + clone.objectiveDisplayName = this.objectiveDisplayName.witClone; + clone.criteriaName = this.criteriaName.witClone; + clone.sortOrder = this.sortOrder.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetHealth { + /++ + + +/ + int health; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CSetHealth witClone() const @nogc nothrow { + CSetHealth clone = void; + clone.health = this.health.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetPlayerGameType { + /++ + + +/ + GameType playerGameType; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CSetPlayerGameType witClone() const @nogc nothrow { + CSetPlayerGameType clone = void; + clone.playerGameType = this.playerGameType.witClone; + return clone; + } +} + +/++ + ++/ +struct ScoreEntry { + /++ + + +/ + long scoreboardId; + + /++ + + +/ + WitString objectiveName; + + /++ + + +/ + int score; + + /++ + + +/ + int entryType; + + /++ + + +/ + long entityUniqueId; + + /++ + + +/ + WitString customName; + + void witFree() @nogc nothrow { + objectiveName.witFree; + customName.witFree; + } + + void witDrop() @nogc nothrow { + } + + ScoreEntry witClone() const @nogc nothrow { + ScoreEntry clone = void; + clone.scoreboardId = this.scoreboardId.witClone; + clone.objectiveName = this.objectiveName.witClone; + clone.score = this.score.witClone; + clone.entryType = this.entryType.witClone; + clone.entityUniqueId = this.entityUniqueId.witClone; + clone.customName = this.customName.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetScore { + /++ + + +/ + int action; + + /++ + + +/ + WitList!(ScoreEntry) entries; + + void witFree() @nogc nothrow { + entries.witFree; + } + + void witDrop() @nogc nothrow { + } + + CSetScore witClone() const @nogc nothrow { + CSetScore clone = void; + clone.action = this.action.witClone; + clone.entries = this.entries.witClone; + return clone; + } +} + +/++ + ++/ +enum SpawnPositionType : ubyte { + /++ + + +/ + playerRespawn, + + /++ + + +/ + worldRespawn, +} +/++ + ++/ +struct CSetSpawnPosition { + /++ + + +/ + SpawnPositionType spawnPositionType; + + /++ + + +/ + Tuple!(int, int, int) blockPosition; + + /++ + + +/ + int dimensionType; + + /++ + + +/ + Tuple!(int, int, int) spawnBlockPos; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CSetSpawnPosition witClone() const @nogc nothrow { + CSetSpawnPosition clone = void; + clone.spawnPositionType = this.spawnPositionType.witClone; + clone.blockPosition = this.blockPosition.witClone; + clone.dimensionType = this.dimensionType.witClone; + clone.spawnBlockPos = this.spawnBlockPos.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetTime { + /++ + + +/ + int time; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CSetTime witClone() const @nogc nothrow { + CSetTime clone = void; + clone.time = this.time.witClone; + return clone; + } +} + +/++ + ++/ +enum TitleType : ubyte { + /++ + + +/ + clear, + + /++ + + +/ + reset, + + /++ + + +/ + title, + + /++ + + +/ + subtitle, + + /++ + + +/ + actionbar, + + /++ + + +/ + times, + + /++ + + +/ + titleTextObject, + + /++ + + +/ + subtitleTextObject, + + /++ + + +/ + actionbarTextObject, +} +/++ + ++/ +struct CSetTitle { + /++ + + +/ + TitleType titleType; + + /++ + + +/ + WitString titleText; + + /++ + + +/ + int fadeInTime; + + /++ + + +/ + int stayTime; + + /++ + + +/ + int fadeOutTime; + + /++ + + +/ + WitString xuid; + + /++ + + +/ + WitString platformOnlineId; + + /++ + + +/ + WitString filteredTitleMessage; + + void witFree() @nogc nothrow { + titleText.witFree; + xuid.witFree; + platformOnlineId.witFree; + filteredTitleMessage.witFree; + } + + void witDrop() @nogc nothrow { + } + + CSetTitle witClone() const @nogc nothrow { + CSetTitle clone = void; + clone.titleType = this.titleType.witClone; + clone.titleText = this.titleText.witClone; + clone.fadeInTime = this.fadeInTime.witClone; + clone.stayTime = this.stayTime.witClone; + clone.fadeOutTime = this.fadeOutTime.witClone; + clone.xuid = this.xuid.witClone; + clone.platformOnlineId = this.platformOnlineId.witClone; + clone.filteredTitleMessage = this.filteredTitleMessage.witClone; + return clone; + } +} + +/++ + ++/ +struct CShowCredits { + /++ + + +/ + long playerRuntimeId; + + /++ + + +/ + int creditsState; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CShowCredits witClone() const @nogc nothrow { + CShowCredits clone = void; + clone.playerRuntimeId = this.playerRuntimeId.witClone; + clone.creditsState = this.creditsState.witClone; + return clone; + } +} + +/++ + ++/ +struct GatheringJoinInfo { + /++ + + +/ + Uuid experienceId; + + /++ + + +/ + WitString experienceName; + + /++ + + +/ + Uuid experienceWorldId; + + /++ + + +/ + WitString experienceWorldName; + + /++ + + +/ + WitString creatorId; + + /++ + + +/ + Uuid unknownUuid1; + + /++ + + +/ + Uuid unknownUuid2; + + /++ + + +/ + WitString serverId; + + void witFree() @nogc nothrow { + experienceName.witFree; + experienceWorldName.witFree; + creatorId.witFree; + serverId.witFree; + } + + void witDrop() @nogc nothrow { + } + + GatheringJoinInfo witClone() const @nogc nothrow { + GatheringJoinInfo clone = void; + clone.experienceId = this.experienceId.witClone; + clone.experienceName = this.experienceName.witClone; + clone.experienceWorldId = this.experienceWorldId.witClone; + clone.experienceWorldName = this.experienceWorldName.witClone; + clone.creatorId = this.creatorId.witClone; + clone.unknownUuid1 = this.unknownUuid1.witClone; + clone.unknownUuid2 = this.unknownUuid2.witClone; + clone.serverId = this.serverId.witClone; + return clone; + } +} + +/++ + ++/ +struct StoreEntryPointInfo { + /++ + + +/ + WitString storeId; + + /++ + + +/ + WitString storeName; + + void witFree() @nogc nothrow { + storeId.witFree; + storeName.witFree; + } + + void witDrop() @nogc nothrow { + } + + StoreEntryPointInfo witClone() const @nogc nothrow { + StoreEntryPointInfo clone = void; + clone.storeId = this.storeId.witClone; + clone.storeName = this.storeName.witClone; + return clone; + } +} + +/++ + ++/ +struct PresenceInfo { + /++ + + +/ + WitString experienceName; + + /++ + + +/ + WitString worldName; + + void witFree() @nogc nothrow { + experienceName.witFree; + worldName.witFree; + } + + void witDrop() @nogc nothrow { + } + + PresenceInfo witClone() const @nogc nothrow { + PresenceInfo clone = void; + clone.experienceName = this.experienceName.witClone; + clone.worldName = this.worldName.witClone; + return clone; + } +} + +/++ + ++/ +struct ServerJoinInformation { + /++ + + +/ + Option!(GatheringJoinInfo) gathering; + + /++ + + +/ + Option!(StoreEntryPointInfo) storeEntryPoint; + + /++ + + +/ + Option!(PresenceInfo) presence; + + void witFree() @nogc nothrow { + gathering.witFree; + storeEntryPoint.witFree; + presence.witFree; + } + + void witDrop() @nogc nothrow { + } + + ServerJoinInformation witClone() const @nogc nothrow { + ServerJoinInformation clone = void; + clone.gathering = this.gathering.witClone; + clone.storeEntryPoint = this.storeEntryPoint.witClone; + clone.presence = this.presence.witClone; + return clone; + } +} + +/++ + ++/ +struct ServerTelemetryData { + /++ + + +/ + WitString serverId; + + /++ + + +/ + WitString scenarioId; + + /++ + + +/ + WitString worldId; + + /++ + + +/ + WitString ownerId; + + void witFree() @nogc nothrow { + serverId.witFree; + scenarioId.witFree; + worldId.witFree; + ownerId.witFree; + } + + void witDrop() @nogc nothrow { + } + + ServerTelemetryData witClone() const @nogc nothrow { + ServerTelemetryData clone = void; + clone.serverId = this.serverId.witClone; + clone.scenarioId = this.scenarioId.witClone; + clone.worldId = this.worldId.witClone; + clone.ownerId = this.ownerId.witClone; + return clone; + } +} + +/++ + ++/ +struct ExperimentToggle { + /++ + + +/ + WitString name; + + /++ + + +/ + bool enabled; + + void witFree() @nogc nothrow { + name.witFree; + } + + void witDrop() @nogc nothrow { + } + + ExperimentToggle witClone() const @nogc nothrow { + ExperimentToggle clone = void; + clone.name = this.name.witClone; + clone.enabled = this.enabled.witClone; + return clone; + } +} + +/++ + ++/ +struct Experiments { + /++ + + +/ + WitList!(ExperimentToggle) toggles; + + /++ + + +/ + bool experimentsEverToggled; + + void witFree() @nogc nothrow { + toggles.witFree; + } + + void witDrop() @nogc nothrow { + } + + Experiments witClone() const @nogc nothrow { + Experiments clone = void; + clone.toggles = this.toggles.witClone; + clone.experimentsEverToggled = this.experimentsEverToggled.witClone; + return clone; + } +} + +/++ + ++/ +struct CResourcePackStackPacket { + /++ + + +/ + bool texturePackRequired; + + /++ + + +/ + WitList!(PackInstanceId) texturePackList; + + /++ + + +/ + WitString baseGameVersion; + + /++ + + +/ + Experiments experiments; + + /++ + + +/ + bool includeEditorPacks; + + void witFree() @nogc nothrow { + texturePackList.witFree; + baseGameVersion.witFree; + experiments.witFree; + } + + void witDrop() @nogc nothrow { + } + + CResourcePackStackPacket witClone() const @nogc nothrow { + CResourcePackStackPacket clone = void; + clone.texturePackRequired = this.texturePackRequired.witClone; + clone.texturePackList = this.texturePackList.witClone; + clone.baseGameVersion = this.baseGameVersion.witClone; + clone.experiments = this.experiments.witClone; + clone.includeEditorPacks = this.includeEditorPacks.witClone; + return clone; + } +} + +/++ + ++/ +enum GamePublishSetting : ubyte { + /++ + + +/ + noMultiPlay, + + /++ + + +/ + inviteOnly, + + /++ + + +/ + friendsOnly, + + /++ + + +/ + friendsOfFriends, + + /++ + + +/ + public_, +} +/++ + ++/ +struct LevelSettings { + /++ + + +/ + long seed; + + /++ + + +/ + int spawnBiomeType; + + /++ + + +/ + WitString customBiomeName; + + /++ + + +/ + int dimension; + + /++ + + +/ + int generatorType; + + /++ + + +/ + GameType worldGamemode; + + /++ + + +/ + bool hardcore; + + /++ + + +/ + int difficulty; + + /++ + + +/ + Tuple!(int, int, int) spawnPosition; + + /++ + + +/ + bool hasAchievementsDisabled; + + /++ + + +/ + int editorWorldType; + + /++ + + +/ + bool isCreatedInEditor; + + /++ + + +/ + bool isExportedFromEditor; + + /++ + + +/ + int dayCycleStopTime; + + /++ + + +/ + int educationEditionOffer; + + /++ + + +/ + bool hasEducationFeaturesEnabled; + + /++ + + +/ + WitString educationProductId; + + /++ + + +/ + float rainLevel; + + /++ + + +/ + float lightningLevel; + + /++ + + +/ + bool hasConfirmedPlatformLockedContent; + + /++ + + +/ + bool wasMultiplayerIntended; + + /++ + + +/ + bool wasLanBroadcastingIntended; + + /++ + + +/ + GamePublishSetting xboxLiveBroadcastSetting; + + /++ + + +/ + GamePublishSetting platformBroadcastSetting; + + /++ + + +/ + bool commandsEnabled; + + /++ + + +/ + bool isTexturePacksRequired; + + /++ + + +/ + WitList!(GameRule) ruleData; + + /++ + + +/ + Experiments experiments; + + /++ + + +/ + bool bonusChest; + + /++ + + +/ + bool hasStartWithMapEnabled; + + /++ + + +/ + ubyte permissionLevel; + + /++ + + +/ + int serverSimulationDistance; + + /++ + + +/ + bool hasLockedBehaviorPack; + + /++ + + +/ + bool hasLockedResourcePack; + + /++ + + +/ + bool isFromLockedWorldTemplate; + + /++ + + +/ + bool isUsingMsaGamertagsOnly; + + /++ + + +/ + bool isFromWorldTemplate; + + /++ + + +/ + bool isWorldTemplateOptionLocked; + + /++ + + +/ + bool isOnlySpawningV1Villagers; + + /++ + + +/ + bool isDisablingPersonas; + + /++ + + +/ + bool isDisablingCustomSkins; + + /++ + + +/ + bool emoteChatMuted; + + /++ + + +/ + WitString gameVersion; + + /++ + + +/ + int limitedWorldWidth; + + /++ + + +/ + int limitedWorldHeight; + + /++ + + +/ + bool newNether; + + /++ + + +/ + WitString eduSharedUriButtonName; + + /++ + + +/ + WitString eduSharedUriLinkUri; + + /++ + + +/ + bool overrideForceExperimentalGameplayHasValue; + + /++ + + +/ + ubyte chatRestrictionLevel; + + /++ + + +/ + bool disablePlayerInteractions; + + /++ + + +/ + int serverEditorConnectionPolicy; + + /++ + + +/ + bool allowAnonymousBlockDropsInEditorWorlds; + + void witFree() @nogc nothrow { + customBiomeName.witFree; + educationProductId.witFree; + ruleData.witFree; + experiments.witFree; + gameVersion.witFree; + eduSharedUriButtonName.witFree; + eduSharedUriLinkUri.witFree; + } + + void witDrop() @nogc nothrow { + } + + LevelSettings witClone() const @nogc nothrow { + LevelSettings clone = void; + clone.seed = this.seed.witClone; + clone.spawnBiomeType = this.spawnBiomeType.witClone; + clone.customBiomeName = this.customBiomeName.witClone; + clone.dimension = this.dimension.witClone; + clone.generatorType = this.generatorType.witClone; + clone.worldGamemode = this.worldGamemode.witClone; + clone.hardcore = this.hardcore.witClone; + clone.difficulty = this.difficulty.witClone; + clone.spawnPosition = this.spawnPosition.witClone; + clone.hasAchievementsDisabled = this.hasAchievementsDisabled.witClone; + clone.editorWorldType = this.editorWorldType.witClone; + clone.isCreatedInEditor = this.isCreatedInEditor.witClone; + clone.isExportedFromEditor = this.isExportedFromEditor.witClone; + clone.dayCycleStopTime = this.dayCycleStopTime.witClone; + clone.educationEditionOffer = this.educationEditionOffer.witClone; + clone.hasEducationFeaturesEnabled = this.hasEducationFeaturesEnabled.witClone; + clone.educationProductId = this.educationProductId.witClone; + clone.rainLevel = this.rainLevel.witClone; + clone.lightningLevel = this.lightningLevel.witClone; + clone.hasConfirmedPlatformLockedContent = this.hasConfirmedPlatformLockedContent.witClone; + clone.wasMultiplayerIntended = this.wasMultiplayerIntended.witClone; + clone.wasLanBroadcastingIntended = this.wasLanBroadcastingIntended.witClone; + clone.xboxLiveBroadcastSetting = this.xboxLiveBroadcastSetting.witClone; + clone.platformBroadcastSetting = this.platformBroadcastSetting.witClone; + clone.commandsEnabled = this.commandsEnabled.witClone; + clone.isTexturePacksRequired = this.isTexturePacksRequired.witClone; + clone.ruleData = this.ruleData.witClone; + clone.experiments = this.experiments.witClone; + clone.bonusChest = this.bonusChest.witClone; + clone.hasStartWithMapEnabled = this.hasStartWithMapEnabled.witClone; + clone.permissionLevel = this.permissionLevel.witClone; + clone.serverSimulationDistance = this.serverSimulationDistance.witClone; + clone.hasLockedBehaviorPack = this.hasLockedBehaviorPack.witClone; + clone.hasLockedResourcePack = this.hasLockedResourcePack.witClone; + clone.isFromLockedWorldTemplate = this.isFromLockedWorldTemplate.witClone; + clone.isUsingMsaGamertagsOnly = this.isUsingMsaGamertagsOnly.witClone; + clone.isFromWorldTemplate = this.isFromWorldTemplate.witClone; + clone.isWorldTemplateOptionLocked = this.isWorldTemplateOptionLocked.witClone; + clone.isOnlySpawningV1Villagers = this.isOnlySpawningV1Villagers.witClone; + clone.isDisablingPersonas = this.isDisablingPersonas.witClone; + clone.isDisablingCustomSkins = this.isDisablingCustomSkins.witClone; + clone.emoteChatMuted = this.emoteChatMuted.witClone; + clone.gameVersion = this.gameVersion.witClone; + clone.limitedWorldWidth = this.limitedWorldWidth.witClone; + clone.limitedWorldHeight = this.limitedWorldHeight.witClone; + clone.newNether = this.newNether.witClone; + clone.eduSharedUriButtonName = this.eduSharedUriButtonName.witClone; + clone.eduSharedUriLinkUri = this.eduSharedUriLinkUri.witClone; + clone.overrideForceExperimentalGameplayHasValue = this.overrideForceExperimentalGameplayHasValue.witClone; + clone.chatRestrictionLevel = this.chatRestrictionLevel.witClone; + clone.disablePlayerInteractions = this.disablePlayerInteractions.witClone; + clone.serverEditorConnectionPolicy = this.serverEditorConnectionPolicy.witClone; + clone.allowAnonymousBlockDropsInEditorWorlds = this.allowAnonymousBlockDropsInEditorWorlds.witClone; + return clone; + } +} + +/++ + ++/ +struct CStartGame { + /++ + + +/ + long entityId; + + /++ + + +/ + long runtimeEntityId; + + /++ + + +/ + GameType playerGamemode; + + /++ + + +/ + Tuple!(double, double, double) position; + + /++ + + +/ + float pitch; + + /++ + + +/ + float yaw; + + /++ + + +/ + LevelSettings levelSettings; + + /++ + + +/ + WitString levelId; + + /++ + + +/ + WitString levelName; + + /++ + + +/ + WitString premiumWorldTemplateId; + + /++ + + +/ + bool isTrial; + + /++ + + +/ + int rewindHistorySize; + + /++ + + +/ + bool serverAuthoritativeBlockBreaking; + + /++ + + +/ + long currentLevelTime; + + /++ + + +/ + int enchantmentSeed; + + /++ + + +/ + int blockPropertiesSize; + + /++ + + +/ + WitString multiplayerCorrelationId; + + /++ + + +/ + bool enableItemstackNetManager; + + /++ + + +/ + WitString serverVersion; + + /++ + + +/ + ubyte compoundId; + + /++ + + +/ + int compoundLen; + + /++ + + +/ + ubyte compoundEnd; + + /++ + + +/ + long blockRegistryChecksum; + + /++ + + +/ + Uuid worldTemplateId; + + /++ + + +/ + bool enableClientsideGeneration; + + /++ + + +/ + bool blocknetworkIdsAreHashed; + + /++ + + +/ + bool serverAuthSounds; + + /++ + + +/ + Option!(ServerJoinInformation) serverJoinInformation; + + /++ + + +/ + ServerTelemetryData telemetry; + + void witFree() @nogc nothrow { + levelSettings.witFree; + levelId.witFree; + levelName.witFree; + premiumWorldTemplateId.witFree; + multiplayerCorrelationId.witFree; + serverVersion.witFree; + serverJoinInformation.witFree; + telemetry.witFree; + } + + void witDrop() @nogc nothrow { + } + + CStartGame witClone() const @nogc nothrow { + CStartGame clone = void; + clone.entityId = this.entityId.witClone; + clone.runtimeEntityId = this.runtimeEntityId.witClone; + clone.playerGamemode = this.playerGamemode.witClone; + clone.position = this.position.witClone; + clone.pitch = this.pitch.witClone; + clone.yaw = this.yaw.witClone; + clone.levelSettings = this.levelSettings.witClone; + clone.levelId = this.levelId.witClone; + clone.levelName = this.levelName.witClone; + clone.premiumWorldTemplateId = this.premiumWorldTemplateId.witClone; + clone.isTrial = this.isTrial.witClone; + clone.rewindHistorySize = this.rewindHistorySize.witClone; + clone.serverAuthoritativeBlockBreaking = this.serverAuthoritativeBlockBreaking.witClone; + clone.currentLevelTime = this.currentLevelTime.witClone; + clone.enchantmentSeed = this.enchantmentSeed.witClone; + clone.blockPropertiesSize = this.blockPropertiesSize.witClone; + clone.multiplayerCorrelationId = this.multiplayerCorrelationId.witClone; + clone.enableItemstackNetManager = this.enableItemstackNetManager.witClone; + clone.serverVersion = this.serverVersion.witClone; + clone.compoundId = this.compoundId.witClone; + clone.compoundLen = this.compoundLen.witClone; + clone.compoundEnd = this.compoundEnd.witClone; + clone.blockRegistryChecksum = this.blockRegistryChecksum.witClone; + clone.worldTemplateId = this.worldTemplateId.witClone; + clone.enableClientsideGeneration = this.enableClientsideGeneration.witClone; + clone.blocknetworkIdsAreHashed = this.blocknetworkIdsAreHashed.witClone; + clone.serverAuthSounds = this.serverAuthSounds.witClone; + clone.serverJoinInformation = this.serverJoinInformation.witClone; + clone.telemetry = this.telemetry.witClone; + return clone; + } +} + +/++ + ++/ +struct Gg { + /++ + + +/ + WitString name; + + /++ + + +/ + ubyte id; + + /++ + + +/ + int len; + + /++ + + +/ + ubyte end; + + void witFree() @nogc nothrow { + name.witFree; + } + + void witDrop() @nogc nothrow { + } + + Gg witClone() const @nogc nothrow { + Gg clone = void; + clone.name = this.name.witClone; + clone.id = this.id.witClone; + clone.len = this.len.witClone; + clone.end = this.end.witClone; + return clone; + } +} + +/++ + ++/ +struct CTakeItemActor { + /++ + + +/ + long itemRuntimeId; + + /++ + + +/ + long actorRuntimeId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CTakeItemActor witClone() const @nogc nothrow { + CTakeItemActor clone = void; + clone.itemRuntimeId = this.itemRuntimeId.witClone; + clone.actorRuntimeId = this.actorRuntimeId.witClone; + return clone; + } +} + +/++ + ++/ +struct CTransfer { + /++ + + +/ + WitString serverAddress; + + /++ + + +/ + int serverPort; + + /++ + + +/ + bool reloadWorld; + + void witFree() @nogc nothrow { + serverAddress.witFree; + } + + void witDrop() @nogc nothrow { + } + + CTransfer witClone() const @nogc nothrow { + CTransfer clone = void; + clone.serverAddress = this.serverAddress.witClone; + clone.serverPort = this.serverPort.witClone; + clone.reloadWorld = this.reloadWorld.witClone; + return clone; + } +} + +/++ + ++/ +struct CUpdateAbilities { + /++ + + +/ + SerializedAbilitiesData data; + + void witFree() @nogc nothrow { + data.witFree; + } + + void witDrop() @nogc nothrow { + } + + CUpdateAbilities witClone() const @nogc nothrow { + CUpdateAbilities clone = void; + clone.data = this.data.witClone; + return clone; + } +} + +/++ + ++/ +enum Ability : ubyte { + /++ + + +/ + build, + + /++ + + +/ + mine, + + /++ + + +/ + doorsAndSwitches, + + /++ + + +/ + openContainers, + + /++ + + +/ + attackPlayers, + + /++ + + +/ + attackMobs, + + /++ + + +/ + operatorCommands, + + /++ + + +/ + teleport, + + /++ + + +/ + invulnerable, + + /++ + + +/ + flying, + + /++ + + +/ + mayFly, + + /++ + + +/ + instabuild, + + /++ + + +/ + lightning, + + /++ + + +/ + flySpeed, + + /++ + + +/ + walkSpeed, + + /++ + + +/ + muted, + + /++ + + +/ + worldBuilder, + + /++ + + +/ + noClip, + + /++ + + +/ + privilegedBuilder, + + /++ + + +/ + verticalFlySpeed, + + /++ + + +/ + abilityCount, +} +/++ + ++/ +struct AttributeModifier { + /++ + + +/ + WitString id; + + /++ + + +/ + WitString name; + + /++ + + +/ + float amount; + + /++ + + +/ + int operation; + + /++ + + +/ + int operand; + + /++ + + +/ + bool isSerializable; + + void witFree() @nogc nothrow { + id.witFree; + name.witFree; + } + + void witDrop() @nogc nothrow { + } + + AttributeModifier witClone() const @nogc nothrow { + AttributeModifier clone = void; + clone.id = this.id.witClone; + clone.name = this.name.witClone; + clone.amount = this.amount.witClone; + clone.operation = this.operation.witClone; + clone.operand = this.operand.witClone; + clone.isSerializable = this.isSerializable.witClone; + return clone; + } +} + +/++ + ++/ +struct AttributeData { + /++ + + +/ + float minValue; + + /++ + + +/ + float maxValue; + + /++ + + +/ + float currentValue; + + /++ + + +/ + float defaultMinValue; + + /++ + + +/ + float defaultMaxValue; + + /++ + + +/ + float defaultValue; + + /++ + + +/ + WitString name; + + /++ + + +/ + WitList!(AttributeModifier) modifiers; + + void witFree() @nogc nothrow { + name.witFree; + modifiers.witFree; + } + + void witDrop() @nogc nothrow { + } + + AttributeData witClone() const @nogc nothrow { + AttributeData clone = void; + clone.minValue = this.minValue.witClone; + clone.maxValue = this.maxValue.witClone; + clone.currentValue = this.currentValue.witClone; + clone.defaultMinValue = this.defaultMinValue.witClone; + clone.defaultMaxValue = this.defaultMaxValue.witClone; + clone.defaultValue = this.defaultValue.witClone; + clone.name = this.name.witClone; + clone.modifiers = this.modifiers.witClone; + return clone; + } +} + +/++ + ++/ +struct CUpdateAttributes { + /++ + + +/ + long targetRuntimeId; + + /++ + + +/ + WitList!(AttributeData) attributeList; + + /++ + + +/ + long tick; + + void witFree() @nogc nothrow { + attributeList.witFree; + } + + void witDrop() @nogc nothrow { + } + + CUpdateAttributes witClone() const @nogc nothrow { + CUpdateAttributes clone = void; + clone.targetRuntimeId = this.targetRuntimeId.witClone; + clone.attributeList = this.attributeList.witClone; + clone.tick = this.tick.witClone; + return clone; + } +} + +/++ + ++/ +struct CUpdateBlock { + /++ + + +/ + Tuple!(int, int, int) blockPosition; + + /++ + + +/ + int blockRuntimeId; + + /++ + + +/ + int flags; + + /++ + + +/ + int layer; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CUpdateBlock witClone() const @nogc nothrow { + CUpdateBlock clone = void; + clone.blockPosition = this.blockPosition.witClone; + clone.blockRuntimeId = this.blockRuntimeId.witClone; + clone.flags = this.flags.witClone; + clone.layer = this.layer.witClone; + return clone; + } +} + +/++ + ++/ +struct CUpdateTrade { + /++ + + +/ + ubyte containerId; + + /++ + + +/ + ubyte rType; + + /++ + + +/ + int size; + + /++ + + +/ + int traderTier; + + /++ + + +/ + long entityUniqueId; + + /++ + + +/ + long lastTradingPlayer; + + /++ + + +/ + WitString displayName; + + /++ + + +/ + bool useNewTradeScreen; + + /++ + + +/ + bool usingEconomyTrade; + + /++ + + +/ + WitString data; + + void witFree() @nogc nothrow { + displayName.witFree; + data.witFree; + } + + void witDrop() @nogc nothrow { + } + + CUpdateTrade witClone() const @nogc nothrow { + CUpdateTrade clone = void; + clone.containerId = this.containerId.witClone; + clone.rType = this.rType.witClone; + clone.size = this.size.witClone; + clone.traderTier = this.traderTier.witClone; + clone.entityUniqueId = this.entityUniqueId.witClone; + clone.lastTradingPlayer = this.lastTradingPlayer.witClone; + clone.displayName = this.displayName.witClone; + clone.useNewTradeScreen = this.useNewTradeScreen.witClone; + clone.usingEconomyTrade = this.usingEconomyTrade.witClone; + clone.data = this.data.witClone; + return clone; + } +} + +/++ + ++/ +struct NetworkItemDescriptor { + /++ + + +/ + int id; + + /++ + + +/ + int stackSize; + + /++ + + +/ + int auxValue; + + /++ + + +/ + int blockRuntimeId; + + /++ + + +/ + WitString nbtData; + + /++ + + +/ + WitList!(WitString) placeOnBlocks; + + /++ + + +/ + WitList!(WitString) destroyBlocks; + + /++ + + +/ + long shieldBlockingTick; + + void witFree() @nogc nothrow { + nbtData.witFree; + placeOnBlocks.witFree; + destroyBlocks.witFree; + } + + void witDrop() @nogc nothrow { + } + + NetworkItemDescriptor witClone() const @nogc nothrow { + NetworkItemDescriptor clone = void; + clone.id = this.id.witClone; + clone.stackSize = this.stackSize.witClone; + clone.auxValue = this.auxValue.witClone; + clone.blockRuntimeId = this.blockRuntimeId.witClone; + clone.nbtData = this.nbtData.witClone; + clone.placeOnBlocks = this.placeOnBlocks.witClone; + clone.destroyBlocks = this.destroyBlocks.witClone; + clone.shieldBlockingTick = this.shieldBlockingTick.witClone; + return clone; + } +} + +/++ + ++/ +struct InventoryAction { + /++ + + +/ + int sourceType; + + /++ + + +/ + Option!(int) windowId; + + /++ + + +/ + Option!(int) sourceFlags; + + /++ + + +/ + int inventorySlot; + + /++ + + +/ + NetworkItemDescriptor oldItem; + + /++ + + +/ + NetworkItemDescriptor newItem; + + void witFree() @nogc nothrow { + oldItem.witFree; + newItem.witFree; + } + + void witDrop() @nogc nothrow { + } + + InventoryAction witClone() const @nogc nothrow { + InventoryAction clone = void; + clone.sourceType = this.sourceType.witClone; + clone.windowId = this.windowId.witClone; + clone.sourceFlags = this.sourceFlags.witClone; + clone.inventorySlot = this.inventorySlot.witClone; + clone.oldItem = this.oldItem.witClone; + clone.newItem = this.newItem.witClone; + return clone; + } +} + +/++ + ++/ +struct UseItemTransactionData { + /++ + + +/ + int actionType; + + /++ + + +/ + ubyte triggerType; + + /++ + + +/ + Tuple!(int, int, int) blockPosition; + + /++ + + +/ + ubyte blockFace; + + /++ + + +/ + int hotBarSlot; + + /++ + + +/ + NetworkItemDescriptor itemInHand; + + /++ + + +/ + Tuple!(double, double, double) playerPosition; + + /++ + + +/ + Tuple!(double, double, double) clickPosition; + + /++ + + +/ + int blockRuntimeId; + + /++ + + +/ + ubyte clientPrediction; + + /++ + + +/ + ubyte clientCooldownState; + + void witFree() @nogc nothrow { + itemInHand.witFree; + } + + void witDrop() @nogc nothrow { + } + + UseItemTransactionData witClone() const @nogc nothrow { + UseItemTransactionData clone = void; + clone.actionType = this.actionType.witClone; + clone.triggerType = this.triggerType.witClone; + clone.blockPosition = this.blockPosition.witClone; + clone.blockFace = this.blockFace.witClone; + clone.hotBarSlot = this.hotBarSlot.witClone; + clone.itemInHand = this.itemInHand.witClone; + clone.playerPosition = this.playerPosition.witClone; + clone.clickPosition = this.clickPosition.witClone; + clone.blockRuntimeId = this.blockRuntimeId.witClone; + clone.clientPrediction = this.clientPrediction.witClone; + clone.clientCooldownState = this.clientCooldownState.witClone; + return clone; + } +} + +/++ + ++/ +struct UseItemOnEntityTransactionData { + /++ + + +/ + long targetEntityRuntimeId; + + /++ + + +/ + int actionType; + + /++ + + +/ + int hotBarSlot; + + /++ + + +/ + NetworkItemDescriptor itemInHand; + + /++ + + +/ + Tuple!(double, double, double) playerPosition; + + /++ + + +/ + Tuple!(double, double, double) clickPosition; + + void witFree() @nogc nothrow { + itemInHand.witFree; + } + + void witDrop() @nogc nothrow { + } + + UseItemOnEntityTransactionData witClone() const @nogc nothrow { + UseItemOnEntityTransactionData clone = void; + clone.targetEntityRuntimeId = this.targetEntityRuntimeId.witClone; + clone.actionType = this.actionType.witClone; + clone.hotBarSlot = this.hotBarSlot.witClone; + clone.itemInHand = this.itemInHand.witClone; + clone.playerPosition = this.playerPosition.witClone; + clone.clickPosition = this.clickPosition.witClone; + return clone; + } +} + +/++ + ++/ +struct ReleaseItemTransactionData { + /++ + + +/ + int actionType; + + /++ + + +/ + int hotBarSlot; + + /++ + + +/ + NetworkItemDescriptor itemInHand; + + /++ + + +/ + Tuple!(double, double, double) headPosition; + + void witFree() @nogc nothrow { + itemInHand.witFree; + } + + void witDrop() @nogc nothrow { + } + + ReleaseItemTransactionData witClone() const @nogc nothrow { + ReleaseItemTransactionData clone = void; + clone.actionType = this.actionType.witClone; + clone.hotBarSlot = this.hotBarSlot.witClone; + clone.itemInHand = this.itemInHand.witClone; + clone.headPosition = this.headPosition.witClone; + return clone; + } +} + +/++ + ++/ +struct TransactionData { + mixin WitVariant!( + WitString, // normal + WitString, // mismatch + UseItemTransactionData, // useItem + UseItemOnEntityTransactionData, // useItemOnEntity + ReleaseItemTransactionData, // releaseItem + ); + +public: + enum Tag : ubyte { + /++ + + +/ + normal, + + /++ + + +/ + mismatch, + + /++ + + +/ + useItem, + + /++ + + +/ + useItemOnEntity, + + /++ + + +/ + releaseItem, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias normal = _create!(Tag.normal); + /// ditto + pragma(inline, true) bool isNormal() const => _tag == Tag.normal; + ///ditto + alias getNormal = _get!(Tag.normal); + + /++ + + +/ + alias mismatch = _create!(Tag.mismatch); + /// ditto + pragma(inline, true) bool isMismatch() const => _tag == Tag.mismatch; + ///ditto + alias getMismatch = _get!(Tag.mismatch); + + /++ + + +/ + alias useItem = _create!(Tag.useItem); + /// ditto + pragma(inline, true) bool isUseItem() const => _tag == Tag.useItem; + ///ditto + alias getUseItem = _get!(Tag.useItem); + + /++ + + +/ + alias useItemOnEntity = _create!(Tag.useItemOnEntity); + /// ditto + pragma(inline, true) bool isUseItemOnEntity() const => _tag == Tag.useItemOnEntity; + ///ditto + alias getUseItemOnEntity = _get!(Tag.useItemOnEntity); + + /++ + + +/ + alias releaseItem = _create!(Tag.releaseItem); + /// ditto + pragma(inline, true) bool isReleaseItem() const => _tag == Tag.releaseItem; + ///ditto + alias getReleaseItem = _get!(Tag.releaseItem); + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case normal: _get!(Tag.normal).witFree; break; + case mismatch: _get!(Tag.mismatch).witFree; break; + case useItem: _get!(Tag.useItem).witFree; break; + case useItemOnEntity: _get!(Tag.useItemOnEntity).witFree; break; + case releaseItem: _get!(Tag.releaseItem).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + } + + TransactionData witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.normal: return _create!(Tag.normal)(this._get!(Tag.normal).witClone); break; + case Tag.mismatch: return _create!(Tag.mismatch)(this._get!(Tag.mismatch).witClone); break; + case Tag.useItem: return _create!(Tag.useItem)(this._get!(Tag.useItem).witClone); break; + case Tag.useItemOnEntity: return _create!(Tag.useItemOnEntity)(this._get!(Tag.useItemOnEntity).witClone); break; + case Tag.releaseItem: return _create!(Tag.releaseItem)(this._get!(Tag.releaseItem).witClone); break; + } + } +} + +/++ + ++/ +struct SInventoryTransaction { + /++ + + +/ + int legacyRequestId; + + /++ + + +/ + WitList!(LegacySetItemSlot) legacySetItemSlots; + + /++ + + +/ + bool hasValue; + + /++ + + +/ + WitList!(InventoryAction) actions; + + /++ + + +/ + int transactionType; + + /++ + + +/ + TransactionData transactionData; + + void witFree() @nogc nothrow { + legacySetItemSlots.witFree; + actions.witFree; + transactionData.witFree; + } + + void witDrop() @nogc nothrow { + } + + SInventoryTransaction witClone() const @nogc nothrow { + SInventoryTransaction clone = void; + clone.legacyRequestId = this.legacyRequestId.witClone; + clone.legacySetItemSlots = this.legacySetItemSlots.witClone; + clone.hasValue = this.hasValue.witClone; + clone.actions = this.actions.witClone; + clone.transactionType = this.transactionType.witClone; + clone.transactionData = this.transactionData.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerUseItemTransactionData { + /++ + + +/ + int actionType; + + /++ + + +/ + ubyte triggerType; + + /++ + + +/ + Tuple!(int, int, int) blockPosition; + + /++ + + +/ + ubyte blockFace; + + /++ + + +/ + int hotBarSlot; + + /++ + + +/ + NetworkItemDescriptor itemInHand; + + /++ + + +/ + Tuple!(double, double, double) playerPosition; + + /++ + + +/ + Tuple!(double, double, double) clickPosition; + + /++ + + +/ + int blockRuntimeId; + + /++ + + +/ + ubyte clientPrediction; + + /++ + + +/ + ubyte clientCooldownState; + + void witFree() @nogc nothrow { + itemInHand.witFree; + } + + void witDrop() @nogc nothrow { + } + + PlayerUseItemTransactionData witClone() const @nogc nothrow { + PlayerUseItemTransactionData clone = void; + clone.actionType = this.actionType.witClone; + clone.triggerType = this.triggerType.witClone; + clone.blockPosition = this.blockPosition.witClone; + clone.blockFace = this.blockFace.witClone; + clone.hotBarSlot = this.hotBarSlot.witClone; + clone.itemInHand = this.itemInHand.witClone; + clone.playerPosition = this.playerPosition.witClone; + clone.clickPosition = this.clickPosition.witClone; + clone.blockRuntimeId = this.blockRuntimeId.witClone; + clone.clientPrediction = this.clientPrediction.witClone; + clone.clientCooldownState = this.clientCooldownState.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerInventoryAction { + /++ + + +/ + int legacyRequestId; + + /++ + + +/ + WitList!(LegacySetItemSlot) legacySlots; + + /++ + + +/ + WitList!(InventoryAction) actions; + + /++ + + +/ + PlayerUseItemTransactionData transaction; + + void witFree() @nogc nothrow { + legacySlots.witFree; + actions.witFree; + transaction.witFree; + } + + void witDrop() @nogc nothrow { + } + + PlayerInventoryAction witClone() const @nogc nothrow { + PlayerInventoryAction clone = void; + clone.legacyRequestId = this.legacyRequestId.witClone; + clone.legacySlots = this.legacySlots.witClone; + clone.actions = this.actions.witClone; + clone.transaction = this.transaction.witClone; + return clone; + } +} + +/++ + ++/ +struct BedrockShapelessRecipe { + /++ + + +/ + WitString recipeId; + + /++ + + +/ + WitList!(ItemDescriptorCount) input; + + /++ + + +/ + WitList!(NetworkItemDescriptor) output; + + /++ + + +/ + Uuid uuid; + + /++ + + +/ + WitString block; + + /++ + + +/ + int priority; + + /++ + + +/ + RecipeUnlockRequirement unlockRequirement; + + /++ + + +/ + int recipeNetworkId; + + void witFree() @nogc nothrow { + recipeId.witFree; + input.witFree; + output.witFree; + block.witFree; + } + + void witDrop() @nogc nothrow { + } + + BedrockShapelessRecipe witClone() const @nogc nothrow { + BedrockShapelessRecipe clone = void; + clone.recipeId = this.recipeId.witClone; + clone.input = this.input.witClone; + clone.output = this.output.witClone; + clone.uuid = this.uuid.witClone; + clone.block = this.block.witClone; + clone.priority = this.priority.witClone; + clone.unlockRequirement = this.unlockRequirement.witClone; + clone.recipeNetworkId = this.recipeNetworkId.witClone; + return clone; + } +} + +/++ + ++/ +struct BedrockShapedRecipe { + /++ + + +/ + WitString recipeId; + + /++ + + +/ + int width; + + /++ + + +/ + int height; + + /++ + + +/ + WitList!(ItemDescriptorCount) input; + + /++ + + +/ + WitList!(NetworkItemDescriptor) output; + + /++ + + +/ + Uuid uuid; + + /++ + + +/ + WitString block; + + /++ + + +/ + int priority; + + /++ + + +/ + bool assumeSymmetry; + + /++ + + +/ + RecipeUnlockRequirement unlockRequirement; + + /++ + + +/ + int recipeNetworkId; + + void witFree() @nogc nothrow { + recipeId.witFree; + input.witFree; + output.witFree; + block.witFree; + } + + void witDrop() @nogc nothrow { + } + + BedrockShapedRecipe witClone() const @nogc nothrow { + BedrockShapedRecipe clone = void; + clone.recipeId = this.recipeId.witClone; + clone.width = this.width.witClone; + clone.height = this.height.witClone; + clone.input = this.input.witClone; + clone.output = this.output.witClone; + clone.uuid = this.uuid.witClone; + clone.block = this.block.witClone; + clone.priority = this.priority.witClone; + clone.assumeSymmetry = this.assumeSymmetry.witClone; + clone.unlockRequirement = this.unlockRequirement.witClone; + clone.recipeNetworkId = this.recipeNetworkId.witClone; + return clone; + } +} + +/++ + ++/ +struct BedrockRecipe { + mixin WitVariant!( + BedrockShapelessRecipe, // shapeless + BedrockShapedRecipe, // shaped + ); + +public: + enum Tag : ubyte { + /++ + + +/ + shapeless, + + /++ + + +/ + shaped, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias shapeless = _create!(Tag.shapeless); + /// ditto + pragma(inline, true) bool isShapeless() const => _tag == Tag.shapeless; + ///ditto + alias getShapeless = _get!(Tag.shapeless); + + /++ + + +/ + alias shaped = _create!(Tag.shaped); + /// ditto + pragma(inline, true) bool isShaped() const => _tag == Tag.shaped; + ///ditto + alias getShaped = _get!(Tag.shaped); + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case shapeless: _get!(Tag.shapeless).witFree; break; + case shaped: _get!(Tag.shaped).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + } + + BedrockRecipe witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.shapeless: return _create!(Tag.shapeless)(this._get!(Tag.shapeless).witClone); break; + case Tag.shaped: return _create!(Tag.shaped)(this._get!(Tag.shaped).witClone); break; + } + } +} + +/++ + ++/ +struct CCraftingData { + /++ + + +/ + WitList!(BedrockRecipe) recipes; + + /++ + + +/ + bool cleanRecipes; + + void witFree() @nogc nothrow { + recipes.witFree; + } + + void witDrop() @nogc nothrow { + } + + CCraftingData witClone() const @nogc nothrow { + CCraftingData clone = void; + clone.recipes = this.recipes.witClone; + clone.cleanRecipes = this.cleanRecipes.witClone; + return clone; + } +} + +/++ + ++/ +struct CreativeGroupInfoPayload { + /++ + + +/ + CreativeCategory creativeCategory; + + /++ + + +/ + WitString name; + + /++ + + +/ + NetworkItemDescriptor groupIconItem; + + void witFree() @nogc nothrow { + name.witFree; + groupIconItem.witFree; + } + + void witDrop() @nogc nothrow { + } + + CreativeGroupInfoPayload witClone() const @nogc nothrow { + CreativeGroupInfoPayload clone = void; + clone.creativeCategory = this.creativeCategory.witClone; + clone.name = this.name.witClone; + clone.groupIconItem = this.groupIconItem.witClone; + return clone; + } +} + +/++ + ++/ +struct CreativeItemEntryPayload { + /++ + + +/ + int id; + + /++ + + +/ + NetworkItemDescriptor item; + + /++ + + +/ + int groupIndex; + + void witFree() @nogc nothrow { + item.witFree; + } + + void witDrop() @nogc nothrow { + } + + CreativeItemEntryPayload witClone() const @nogc nothrow { + CreativeItemEntryPayload clone = void; + clone.id = this.id.witClone; + clone.item = this.item.witClone; + clone.groupIndex = this.groupIndex.witClone; + return clone; + } +} + +/++ + ++/ +struct CCreativeContent { + /++ + + +/ + WitList!(CreativeGroupInfoPayload) groups; + + /++ + + +/ + WitList!(CreativeItemEntryPayload) entries; + + void witFree() @nogc nothrow { + groups.witFree; + entries.witFree; + } + + void witDrop() @nogc nothrow { + } + + CCreativeContent witClone() const @nogc nothrow { + CCreativeContent clone = void; + clone.groups = this.groups.witClone; + clone.entries = this.entries.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemStackWrapper { + /++ + + +/ + int id; + + /++ + + +/ + int stackSize; + + /++ + + +/ + int auxValue; + + /++ + + +/ + int blockRuntimeId; + + /++ + + +/ + WitString nbtData; + + /++ + + +/ + WitList!(WitString) placeOnBlocks; + + /++ + + +/ + WitList!(WitString) destroyBlocks; + + /++ + + +/ + long shieldBlockingTick; + + /++ + + +/ + Option!(int) netId; + + void witFree() @nogc nothrow { + nbtData.witFree; + placeOnBlocks.witFree; + destroyBlocks.witFree; + } + + void witDrop() @nogc nothrow { + } + + ItemStackWrapper witClone() const @nogc nothrow { + ItemStackWrapper clone = void; + clone.id = this.id.witClone; + clone.stackSize = this.stackSize.witClone; + clone.auxValue = this.auxValue.witClone; + clone.blockRuntimeId = this.blockRuntimeId.witClone; + clone.nbtData = this.nbtData.witClone; + clone.placeOnBlocks = this.placeOnBlocks.witClone; + clone.destroyBlocks = this.destroyBlocks.witClone; + clone.shieldBlockingTick = this.shieldBlockingTick.witClone; + clone.netId = this.netId.witClone; + return clone; + } +} + +/++ + ++/ +struct CAddItemActor { + /++ + + +/ + long targetActorId; + + /++ + + +/ + long targetRuntimeId; + + /++ + + +/ + ItemStackWrapper item; + + /++ + + +/ + Tuple!(double, double, double) position; + + /++ + + +/ + Tuple!(double, double, double) velocity; + + /++ + + +/ + WitString entityData; + + /++ + + +/ + bool isFromFishing; + + void witFree() @nogc nothrow { + item.witFree; + entityData.witFree; + } + + void witDrop() @nogc nothrow { + } + + CAddItemActor witClone() const @nogc nothrow { + CAddItemActor clone = void; + clone.targetActorId = this.targetActorId.witClone; + clone.targetRuntimeId = this.targetRuntimeId.witClone; + clone.item = this.item.witClone; + clone.position = this.position.witClone; + clone.velocity = this.velocity.witClone; + clone.entityData = this.entityData.witClone; + clone.isFromFishing = this.isFromFishing.witClone; + return clone; + } +} + +/++ + ++/ +struct NetworkItemStackDescriptor { + /++ + + +/ + int id; + + /++ + + +/ + int stackSize; + + /++ + + +/ + int auxValue; + + /++ + + +/ + int blockRuntimeId; + + /++ + + +/ + WitList!(ubyte) extraData; + + /++ + + +/ + Option!(int) netId; + + void witFree() @nogc nothrow { + extraData.witFree; + } + + void witDrop() @nogc nothrow { + } + + NetworkItemStackDescriptor witClone() const @nogc nothrow { + NetworkItemStackDescriptor clone = void; + clone.id = this.id.witClone; + clone.stackSize = this.stackSize.witClone; + clone.auxValue = this.auxValue.witClone; + clone.blockRuntimeId = this.blockRuntimeId.witClone; + clone.extraData = this.extraData.witClone; + clone.netId = this.netId.witClone; + return clone; + } +} + +/++ + ++/ +struct SMobEquipment { + /++ + + +/ + long entityRuntimeId; + + /++ + + +/ + NetworkItemStackDescriptor item; + + /++ + + +/ + ubyte slot; + + /++ + + +/ + ubyte selectedSlot; + + /++ + + +/ + ubyte containerId; + + void witFree() @nogc nothrow { + item.witFree; + } + + void witDrop() @nogc nothrow { + } + + SMobEquipment witClone() const @nogc nothrow { + SMobEquipment clone = void; + clone.entityRuntimeId = this.entityRuntimeId.witClone; + clone.item = this.item.witClone; + clone.slot = this.slot.witClone; + clone.selectedSlot = this.selectedSlot.witClone; + clone.containerId = this.containerId.witClone; + return clone; + } +} + +/++ + ++/ +struct CAddPlayer { + /++ + + +/ + Uuid uuid; + + /++ + + +/ + WitString playerName; + + /++ + + +/ + long targetRuntimeId; + + /++ + + +/ + WitString platformChatId; + + /++ + + +/ + Tuple!(double, double, double) position; + + /++ + + +/ + Tuple!(double, double, double) velocity; + + /++ + + +/ + Tuple!(double, double) rotation; + + /++ + + +/ + float yHeadRotation; + + /++ + + +/ + NetworkItemStackDescriptor carriedItem; + + /++ + + +/ + GameType playerGameType; + + /++ + + +/ + WitString entityData; + + /++ + + +/ + PropertySyncData syncedProperties; + + /++ + + +/ + SerializedAbilitiesData abilitiesData; + + /++ + + +/ + WitList!(ActorLink) actorLinks; + + /++ + + +/ + WitString deviceId; + + /++ + + +/ + BuildPlatform buildPlatform; + + void witFree() @nogc nothrow { + playerName.witFree; + platformChatId.witFree; + carriedItem.witFree; + entityData.witFree; + syncedProperties.witFree; + abilitiesData.witFree; + actorLinks.witFree; + deviceId.witFree; + } + + void witDrop() @nogc nothrow { + } + + CAddPlayer witClone() const @nogc nothrow { + CAddPlayer clone = void; + clone.uuid = this.uuid.witClone; + clone.playerName = this.playerName.witClone; + clone.targetRuntimeId = this.targetRuntimeId.witClone; + clone.platformChatId = this.platformChatId.witClone; + clone.position = this.position.witClone; + clone.velocity = this.velocity.witClone; + clone.rotation = this.rotation.witClone; + clone.yHeadRotation = this.yHeadRotation.witClone; + clone.carriedItem = this.carriedItem.witClone; + clone.playerGameType = this.playerGameType.witClone; + clone.entityData = this.entityData.witClone; + clone.syncedProperties = this.syncedProperties.witClone; + clone.abilitiesData = this.abilitiesData.witClone; + clone.actorLinks = this.actorLinks.witClone; + clone.deviceId = this.deviceId.witClone; + clone.buildPlatform = this.buildPlatform.witClone; + return clone; + } +} + +/++ + ++/ +struct CMobEquipment { + /++ + + +/ + long targetRuntimeId; + + /++ + + +/ + NetworkItemStackDescriptor item; + + /++ + + +/ + ubyte slot; + + /++ + + +/ + ubyte selectedSlot; + + /++ + + +/ + ubyte containerId; + + void witFree() @nogc nothrow { + item.witFree; + } + + void witDrop() @nogc nothrow { + } + + CMobEquipment witClone() const @nogc nothrow { + CMobEquipment clone = void; + clone.targetRuntimeId = this.targetRuntimeId.witClone; + clone.item = this.item.witClone; + clone.slot = this.slot.witClone; + clone.selectedSlot = this.selectedSlot.witClone; + clone.containerId = this.containerId.witClone; + return clone; + } +} + +/++ + ++/ +enum ContainerName : ubyte { + /++ + + +/ + anvilInput, + + /++ + + +/ + anvilMaterial, + + /++ + + +/ + anvilResultPreview, + + /++ + + +/ + smithingTableInput, + + /++ + + +/ + smithingTableMaterial, + + /++ + + +/ + smithingTableResultPreview, + + /++ + + +/ + armor, + + /++ + + +/ + levelEntity, + + /++ + + +/ + beaconPayment, + + /++ + + +/ + brewingStandInput, + + /++ + + +/ + brewingStandResult, + + /++ + + +/ + brewingStandFuel, + + /++ + + +/ + combinedHotBarAndInventory, + + /++ + + +/ + craftingInput, + + /++ + + +/ + craftingOutputPreview, + + /++ + + +/ + recipeConstruction, + + /++ + + +/ + recipeNature, + + /++ + + +/ + recipeItems, + + /++ + + +/ + recipeSearch, + + /++ + + +/ + recipeSearchBar, + + /++ + + +/ + recipeEquipment, + + /++ + + +/ + recipeBook, + + /++ + + +/ + enchantingInput, + + /++ + + +/ + enchantingMaterial, + + /++ + + +/ + furnaceFuel, + + /++ + + +/ + furnaceIngredient, + + /++ + + +/ + furnaceResult, + + /++ + + +/ + horseEquip, + + /++ + + +/ + hotBar, + + /++ + + +/ + inventory, + + /++ + + +/ + shulkerBox, + + /++ + + +/ + tradeIngredient1, + + /++ + + +/ + tradeIngredient2, + + /++ + + +/ + tradeResultPreview, + + /++ + + +/ + offhand, + + /++ + + +/ + compoundCreatorInput, + + /++ + + +/ + compoundCreatorOutputPreview, + + /++ + + +/ + elementConstructorOutputPreview, + + /++ + + +/ + materialReducerInput, + + /++ + + +/ + materialReducerOutput, + + /++ + + +/ + labTableInput, + + /++ + + +/ + loomInput, + + /++ + + +/ + loomDye, + + /++ + + +/ + loomMaterial, + + /++ + + +/ + loomResultPreview, + + /++ + + +/ + blastFurnaceIngredient, + + /++ + + +/ + smokerIngredient, + + /++ + + +/ + trade2Ingredient1, + + /++ + + +/ + trade2Ingredient2, + + /++ + + +/ + trade2ResultPreview, + + /++ + + +/ + grindstoneInput, + + /++ + + +/ + grindstoneAdditional, + + /++ + + +/ + grindstoneResultPreview, + + /++ + + +/ + stonecutterInput, + + /++ + + +/ + stonecutterResultPreview, + + /++ + + +/ + cartographyInput, + + /++ + + +/ + cartographyAdditional, + + /++ + + +/ + cartographyResultPreview, + + /++ + + +/ + barrel, + + /++ + + +/ + cursor, + + /++ + + +/ + createdOutput, + + /++ + + +/ + smithingTableTemplate, + + /++ + + +/ + crafterLevelEntity, + + /++ + + +/ + dynamic, + + /++ + + +/ + recipeFood, + + /++ + + +/ + recipeBlocks, + + /++ + + +/ + recipeFurnaceItems, +} +/++ + ++/ +struct FullContainerName { + /++ + + +/ + ContainerName containerName; + + /++ + + +/ + Option!(int) dynamicId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + FullContainerName witClone() const @nogc nothrow { + FullContainerName clone = void; + clone.containerName = this.containerName.witClone; + clone.dynamicId = this.dynamicId.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemStackRequestSlotInfo { + /++ + + +/ + FullContainerName containerName; + + /++ + + +/ + ubyte slotId; + + /++ + + +/ + int stackId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ItemStackRequestSlotInfo witClone() const @nogc nothrow { + ItemStackRequestSlotInfo clone = void; + clone.containerName = this.containerName.witClone; + clone.slotId = this.slotId.witClone; + clone.stackId = this.stackId.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemStackRequestActionTake { + /++ + + +/ + ubyte count; + + /++ + + +/ + ItemStackRequestSlotInfo source; + + /++ + + +/ + ItemStackRequestSlotInfo destination; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ItemStackRequestActionTake witClone() const @nogc nothrow { + ItemStackRequestActionTake clone = void; + clone.count = this.count.witClone; + clone.source = this.source.witClone; + clone.destination = this.destination.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemStackRequestActionPlace { + /++ + + +/ + ubyte count; + + /++ + + +/ + ItemStackRequestSlotInfo source; + + /++ + + +/ + ItemStackRequestSlotInfo destination; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ItemStackRequestActionPlace witClone() const @nogc nothrow { + ItemStackRequestActionPlace clone = void; + clone.count = this.count.witClone; + clone.source = this.source.witClone; + clone.destination = this.destination.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemStackRequestActionSwap { + /++ + + +/ + ItemStackRequestSlotInfo slot1; + + /++ + + +/ + ItemStackRequestSlotInfo slot2; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ItemStackRequestActionSwap witClone() const @nogc nothrow { + ItemStackRequestActionSwap clone = void; + clone.slot1 = this.slot1.witClone; + clone.slot2 = this.slot2.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemStackRequestActionDrop { + /++ + + +/ + ubyte count; + + /++ + + +/ + ItemStackRequestSlotInfo source; + + /++ + + +/ + bool randomly; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ItemStackRequestActionDrop witClone() const @nogc nothrow { + ItemStackRequestActionDrop clone = void; + clone.count = this.count.witClone; + clone.source = this.source.witClone; + clone.randomly = this.randomly.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemStackRequestActionDestroy { + /++ + + +/ + ubyte count; + + /++ + + +/ + ItemStackRequestSlotInfo source; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ItemStackRequestActionDestroy witClone() const @nogc nothrow { + ItemStackRequestActionDestroy clone = void; + clone.count = this.count.witClone; + clone.source = this.source.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemStackRequestActionConsume { + /++ + + +/ + ubyte count; + + /++ + + +/ + ItemStackRequestSlotInfo source; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ItemStackRequestActionConsume witClone() const @nogc nothrow { + ItemStackRequestActionConsume clone = void; + clone.count = this.count.witClone; + clone.source = this.source.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemStackRequestAction { + mixin WitVariant!( + ItemStackRequestActionTake, // take + ItemStackRequestActionPlace, // place + ItemStackRequestActionSwap, // swap + ItemStackRequestActionDrop, // drop + ItemStackRequestActionDestroy, // destroy + ItemStackRequestActionConsume, // consume + ItemStackRequestActionCreate, // create + void, // labTableCombine + ItemStackRequestActionBeaconPayment, // beaconPayment + ItemStackRequestActionMineBlock, // mineBlock + ItemStackRequestActionCraftRecipe, // craftRecipe + ItemStackRequestActionCraftRecipeAuto, // craftRecipeAuto + ItemStackRequestActionCraftCreative, // craftCreative + ItemStackRequestActionOptional, // optional + ItemStackRequestActionGrindstone, // grindstone + ItemStackRequestActionLoom, // loom + void, // craftNonImplemented + ItemStackRequestActionCraftResultsDeprecated, // craftResultsDeprecated + ); + +public: + enum Tag : ubyte { + /++ + + +/ + take, + + /++ + + +/ + place, + + /++ + + +/ + swap, + + /++ + + +/ + drop, + + /++ + + +/ + destroy, + + /++ + + +/ + consume, + + /++ + + +/ + create, + + /++ + + +/ + labTableCombine, + + /++ + + +/ + beaconPayment, + + /++ + + +/ + mineBlock, + + /++ + + +/ + craftRecipe, + + /++ + + +/ + craftRecipeAuto, + + /++ + + +/ + craftCreative, + + /++ + + +/ + optional, + + /++ + + +/ + grindstone, + + /++ + + +/ + loom, + + /++ + + +/ + craftNonImplemented, + + /++ + + +/ + craftResultsDeprecated, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias take = _create!(Tag.take); + /// ditto + pragma(inline, true) bool isTake() const => _tag == Tag.take; + ///ditto + alias getTake = _get!(Tag.take); + + /++ + + +/ + alias place = _create!(Tag.place); + /// ditto + pragma(inline, true) bool isPlace() const => _tag == Tag.place; + ///ditto + alias getPlace = _get!(Tag.place); + + /++ + + +/ + alias swap = _create!(Tag.swap); + /// ditto + pragma(inline, true) bool isSwap() const => _tag == Tag.swap; + ///ditto + alias getSwap = _get!(Tag.swap); + + /++ + + +/ + alias drop = _create!(Tag.drop); + /// ditto + pragma(inline, true) bool isDrop() const => _tag == Tag.drop; + ///ditto + alias getDrop = _get!(Tag.drop); + + /++ + + +/ + alias destroy = _create!(Tag.destroy); + /// ditto + pragma(inline, true) bool isDestroy() const => _tag == Tag.destroy; + ///ditto + alias getDestroy = _get!(Tag.destroy); + + /++ + + +/ + alias consume = _create!(Tag.consume); + /// ditto + pragma(inline, true) bool isConsume() const => _tag == Tag.consume; + ///ditto + alias getConsume = _get!(Tag.consume); + + /++ + + +/ + alias create = _create!(Tag.create); + /// ditto + pragma(inline, true) bool isCreate() const => _tag == Tag.create; + ///ditto + alias getCreate = _get!(Tag.create); + + /++ + + +/ + alias labTableCombine = _create!(Tag.labTableCombine); + /// ditto + pragma(inline, true) bool isLabTableCombine() const => _tag == Tag.labTableCombine; + + /++ + + +/ + alias beaconPayment = _create!(Tag.beaconPayment); + /// ditto + pragma(inline, true) bool isBeaconPayment() const => _tag == Tag.beaconPayment; + ///ditto + alias getBeaconPayment = _get!(Tag.beaconPayment); + + /++ + + +/ + alias mineBlock = _create!(Tag.mineBlock); + /// ditto + pragma(inline, true) bool isMineBlock() const => _tag == Tag.mineBlock; + ///ditto + alias getMineBlock = _get!(Tag.mineBlock); + + /++ + + +/ + alias craftRecipe = _create!(Tag.craftRecipe); + /// ditto + pragma(inline, true) bool isCraftRecipe() const => _tag == Tag.craftRecipe; + ///ditto + alias getCraftRecipe = _get!(Tag.craftRecipe); + + /++ + + +/ + alias craftRecipeAuto = _create!(Tag.craftRecipeAuto); + /// ditto + pragma(inline, true) bool isCraftRecipeAuto() const => _tag == Tag.craftRecipeAuto; + ///ditto + alias getCraftRecipeAuto = _get!(Tag.craftRecipeAuto); + + /++ + + +/ + alias craftCreative = _create!(Tag.craftCreative); + /// ditto + pragma(inline, true) bool isCraftCreative() const => _tag == Tag.craftCreative; + ///ditto + alias getCraftCreative = _get!(Tag.craftCreative); + + /++ + + +/ + alias optional = _create!(Tag.optional); + /// ditto + pragma(inline, true) bool isOptional() const => _tag == Tag.optional; + ///ditto + alias getOptional = _get!(Tag.optional); + + /++ + + +/ + alias grindstone = _create!(Tag.grindstone); + /// ditto + pragma(inline, true) bool isGrindstone() const => _tag == Tag.grindstone; + ///ditto + alias getGrindstone = _get!(Tag.grindstone); + + /++ + + +/ + alias loom = _create!(Tag.loom); + /// ditto + pragma(inline, true) bool isLoom() const => _tag == Tag.loom; + ///ditto + alias getLoom = _get!(Tag.loom); + + /++ + + +/ + alias craftNonImplemented = _create!(Tag.craftNonImplemented); + /// ditto + pragma(inline, true) bool isCraftNonImplemented() const => _tag == Tag.craftNonImplemented; + + /++ + + +/ + alias craftResultsDeprecated = _create!(Tag.craftResultsDeprecated); + /// ditto + pragma(inline, true) bool isCraftResultsDeprecated() const => _tag == Tag.craftResultsDeprecated; + ///ditto + alias getCraftResultsDeprecated = _get!(Tag.craftResultsDeprecated); + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case loom: _get!(Tag.loom).witFree; break; + case craftResultsDeprecated: _get!(Tag.craftResultsDeprecated).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + } + + ItemStackRequestAction witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.take: return _create!(Tag.take)(this._get!(Tag.take).witClone); break; + case Tag.place: return _create!(Tag.place)(this._get!(Tag.place).witClone); break; + case Tag.swap: return _create!(Tag.swap)(this._get!(Tag.swap).witClone); break; + case Tag.drop: return _create!(Tag.drop)(this._get!(Tag.drop).witClone); break; + case Tag.destroy: return _create!(Tag.destroy)(this._get!(Tag.destroy).witClone); break; + case Tag.consume: return _create!(Tag.consume)(this._get!(Tag.consume).witClone); break; + case Tag.create: return _create!(Tag.create)(this._get!(Tag.create).witClone); break; + case Tag.labTableCombine: return _create!(Tag.labTableCombine); break; + case Tag.beaconPayment: return _create!(Tag.beaconPayment)(this._get!(Tag.beaconPayment).witClone); break; + case Tag.mineBlock: return _create!(Tag.mineBlock)(this._get!(Tag.mineBlock).witClone); break; + case Tag.craftRecipe: return _create!(Tag.craftRecipe)(this._get!(Tag.craftRecipe).witClone); break; + case Tag.craftRecipeAuto: return _create!(Tag.craftRecipeAuto)(this._get!(Tag.craftRecipeAuto).witClone); break; + case Tag.craftCreative: return _create!(Tag.craftCreative)(this._get!(Tag.craftCreative).witClone); break; + case Tag.optional: return _create!(Tag.optional)(this._get!(Tag.optional).witClone); break; + case Tag.grindstone: return _create!(Tag.grindstone)(this._get!(Tag.grindstone).witClone); break; + case Tag.loom: return _create!(Tag.loom)(this._get!(Tag.loom).witClone); break; + case Tag.craftNonImplemented: return _create!(Tag.craftNonImplemented); break; + case Tag.craftResultsDeprecated: return _create!(Tag.craftResultsDeprecated)(this._get!(Tag.craftResultsDeprecated).witClone); break; + } + } +} + +/++ + ++/ +struct ItemStackRequest { + /++ + + +/ + int requestId; + + /++ + + +/ + WitList!(ItemStackRequestAction) actions; + + /++ + + +/ + WitList!(WitString) filterStrings; + + /++ + + +/ + int filterCause; + + void witFree() @nogc nothrow { + actions.witFree; + filterStrings.witFree; + } + + void witDrop() @nogc nothrow { + } + + ItemStackRequest witClone() const @nogc nothrow { + ItemStackRequest clone = void; + clone.requestId = this.requestId.witClone; + clone.actions = this.actions.witClone; + clone.filterStrings = this.filterStrings.witClone; + clone.filterCause = this.filterCause.witClone; + return clone; + } +} + +/++ + ++/ +struct SItemStackRequest { + /++ + + +/ + WitList!(ItemStackRequest) requests; + + void witFree() @nogc nothrow { + requests.witFree; + } + + void witDrop() @nogc nothrow { + } + + SItemStackRequest witClone() const @nogc nothrow { + SItemStackRequest clone = void; + clone.requests = this.requests.witClone; + return clone; + } +} + +/++ + ++/ +struct SPlayerAuthInput { + /++ + + +/ + float pitch; + + /++ + + +/ + float yaw; + + /++ + + +/ + Tuple!(double, double, double) position; + + /++ + + +/ + Tuple!(double, double) moveVec; + + /++ + + +/ + float headYaw; + + /++ + + +/ + WitList!(long) inputData; + + /++ + + +/ + int inputMode; + + /++ + + +/ + int playMode; + + /++ + + +/ + int interactionModel; + + /++ + + +/ + float interactPitch; + + /++ + + +/ + float interactYaw; + + /++ + + +/ + long tick; + + /++ + + +/ + Tuple!(double, double, double) delta; + + /++ + + +/ + Option!(WitList!(PlayerBlockAction)) blockActions; + + /++ + + +/ + Option!(PlayerInventoryAction) itemInteraction; + + /++ + + +/ + Option!(ItemStackRequest) itemStackRequest; + + /++ + + +/ + Option!(Tuple!(double, double)) vehicleRotation; + + /++ + + +/ + Option!(long) vehicleUniqueId; + + /++ + + +/ + Tuple!(double, double) analogMove; + + /++ + + +/ + Tuple!(double, double, double) cameraOrientation; + + /++ + + +/ + Tuple!(double, double) rawMove; + + void witFree() @nogc nothrow { + inputData.witFree; + blockActions.witFree; + itemInteraction.witFree; + itemStackRequest.witFree; + } + + void witDrop() @nogc nothrow { + } + + SPlayerAuthInput witClone() const @nogc nothrow { + SPlayerAuthInput clone = void; + clone.pitch = this.pitch.witClone; + clone.yaw = this.yaw.witClone; + clone.position = this.position.witClone; + clone.moveVec = this.moveVec.witClone; + clone.headYaw = this.headYaw.witClone; + clone.inputData = this.inputData.witClone; + clone.inputMode = this.inputMode.witClone; + clone.playMode = this.playMode.witClone; + clone.interactionModel = this.interactionModel.witClone; + clone.interactPitch = this.interactPitch.witClone; + clone.interactYaw = this.interactYaw.witClone; + clone.tick = this.tick.witClone; + clone.delta = this.delta.witClone; + clone.blockActions = this.blockActions.witClone; + clone.itemInteraction = this.itemInteraction.witClone; + clone.itemStackRequest = this.itemStackRequest.witClone; + clone.vehicleRotation = this.vehicleRotation.witClone; + clone.vehicleUniqueId = this.vehicleUniqueId.witClone; + clone.analogMove = this.analogMove.witClone; + clone.cameraOrientation = this.cameraOrientation.witClone; + clone.rawMove = this.rawMove.witClone; + return clone; + } +} + +/++ + ++/ +struct CInventoryContent { + /++ + + +/ + int containerId; + + /++ + + +/ + WitList!(NetworkItemStackDescriptor) slots; + + /++ + + +/ + FullContainerName fullContainerName; + + /++ + + +/ + NetworkItemStackDescriptor storageItem; + + void witFree() @nogc nothrow { + slots.witFree; + storageItem.witFree; + } + + void witDrop() @nogc nothrow { + } + + CInventoryContent witClone() const @nogc nothrow { + CInventoryContent clone = void; + clone.containerId = this.containerId.witClone; + clone.slots = this.slots.witClone; + clone.fullContainerName = this.fullContainerName.witClone; + clone.storageItem = this.storageItem.witClone; + return clone; + } +} + +/++ + ++/ +struct CInventorySlot { + /++ + + +/ + int containerId; + + /++ + + +/ + int slot; + + /++ + + +/ + Option!(FullContainerName) fullContainerName; + + /++ + + +/ + Option!(NetworkItemStackDescriptor) storageItem; + + /++ + + +/ + NetworkItemStackDescriptor item; + + void witFree() @nogc nothrow { + storageItem.witFree; + item.witFree; + } + + void witDrop() @nogc nothrow { + } + + CInventorySlot witClone() const @nogc nothrow { + CInventorySlot clone = void; + clone.containerId = this.containerId.witClone; + clone.slot = this.slot.witClone; + clone.fullContainerName = this.fullContainerName.witClone; + clone.storageItem = this.storageItem.witClone; + clone.item = this.item.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemStackResponseContainerInfo { + /++ + + +/ + FullContainerName fullContainerName; + + /++ + + +/ + WitList!(ItemStackResponseSlotInfo) slots; + + void witFree() @nogc nothrow { + slots.witFree; + } + + void witDrop() @nogc nothrow { + } + + ItemStackResponseContainerInfo witClone() const @nogc nothrow { + ItemStackResponseContainerInfo clone = void; + clone.fullContainerName = this.fullContainerName.witClone; + clone.slots = this.slots.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemStackResponseInfo { + /++ + + +/ + ubyte result; + + /++ + + +/ + int clientRequestId; + + /++ + + +/ + WitList!(ItemStackResponseContainerInfo) containers; + + void witFree() @nogc nothrow { + containers.witFree; + } + + void witDrop() @nogc nothrow { + } + + ItemStackResponseInfo witClone() const @nogc nothrow { + ItemStackResponseInfo clone = void; + clone.result = this.result.witClone; + clone.clientRequestId = this.clientRequestId.witClone; + clone.containers = this.containers.witClone; + return clone; + } +} + +/++ + ++/ +struct CItemStackResponse { + /++ + + +/ + WitList!(ItemStackResponseInfo) responses; + + void witFree() @nogc nothrow { + responses.witFree; + } + + void witDrop() @nogc nothrow { + } + + CItemStackResponse witClone() const @nogc nothrow { + CItemStackResponse clone = void; + clone.responses = this.responses.witClone; + return clone; + } +} + +/++ + ++/ +struct NetworkItemStack { + /++ + + +/ + int id; + + /++ + + +/ + int count; + + /++ + + +/ + int auxValue; + + /++ + + +/ + int blockRuntimeId; + + /++ + + +/ + WitList!(ubyte) extraData; + + void witFree() @nogc nothrow { + extraData.witFree; + } + + void witDrop() @nogc nothrow { + } + + NetworkItemStack witClone() const @nogc nothrow { + NetworkItemStack clone = void; + clone.id = this.id.witClone; + clone.count = this.count.witClone; + clone.auxValue = this.auxValue.witClone; + clone.blockRuntimeId = this.blockRuntimeId.witClone; + clone.extraData = this.extraData.witClone; + return clone; + } +} + +/++ + ++/ +struct ServerboundPacket { + mixin WitVariant!( + SActorEvent, // sActorEvent + SAnimate, // sAnimate + SBlockPickRequest, // sBlockPickRequest + SClientCacheBlobStatus, // sClientCacheBlobStatus + SClientCacheStatus, // sClientCacheStatus + SCommandRequest, // sCommandRequest + SContainerClose, // sContainerClose + SEmote, // sEmote + SEmoteList, // sEmoteList + SInteract, // sInteract + SInventoryTransaction, // sInventoryTransaction + SItemStackRequest, // sItemStackRequest + SLoadingScreen, // sLoadingScreen + SLogin, // sLogin + SMobEquipment, // sMobEquipment + SModalFormResponse, // sModalFormResponse + SPacketViolationWarning, // sPacketViolationWarning + SPlayerAction, // sPlayerAction + SPlayerAuthInput, // sPlayerAuthInput + SPlayerHotbar, // sPlayerHotbar + SRequestAbility, // sRequestAbility + SRequestChunkRadius, // sRequestChunkRadius + SRequestNetworkSettings, // sRequestNetworkSettings + SResourcePackClientResponse, // sResourcePackClientResponse + SRespawn, // sRespawn + SSetLocalPlayerAsInitialized, // sSetLocalPlayerAsInitialized + SSetPlayerInventoryOptions, // sSetPlayerInventoryOptions + SText, // sText + void, // unknown + ); + +public: + enum Tag : ubyte { + /++ + + +/ + sActorEvent, + + /++ + + +/ + sAnimate, + + /++ + + +/ + sBlockPickRequest, + + /++ + + +/ + sClientCacheBlobStatus, + + /++ + + +/ + sClientCacheStatus, + + /++ + + +/ + sCommandRequest, + + /++ + + +/ + sContainerClose, + + /++ + + +/ + sEmote, + + /++ + + +/ + sEmoteList, + + /++ + + +/ + sInteract, + + /++ + + +/ + sInventoryTransaction, + + /++ + + +/ + sItemStackRequest, + + /++ + + +/ + sLoadingScreen, + + /++ + + +/ + sLogin, + + /++ + + +/ + sMobEquipment, + + /++ + + +/ + sModalFormResponse, + + /++ + + +/ + sPacketViolationWarning, + + /++ + + +/ + sPlayerAction, + + /++ + + +/ + sPlayerAuthInput, + + /++ + + +/ + sPlayerHotbar, + + /++ + + +/ + sRequestAbility, + + /++ + + +/ + sRequestChunkRadius, + + /++ + + +/ + sRequestNetworkSettings, + + /++ + + +/ + sResourcePackClientResponse, + + /++ + + +/ + sRespawn, + + /++ + + +/ + sSetLocalPlayerAsInitialized, + + /++ + + +/ + sSetPlayerInventoryOptions, + + /++ + + +/ + sText, + + /++ + + +/ + unknown, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias sActorEvent = _create!(Tag.sActorEvent); + /// ditto + pragma(inline, true) bool isSActorEvent() const => _tag == Tag.sActorEvent; + ///ditto + alias getSActorEvent = _get!(Tag.sActorEvent); + + /++ + + +/ + alias sAnimate = _create!(Tag.sAnimate); + /// ditto + pragma(inline, true) bool isSAnimate() const => _tag == Tag.sAnimate; + ///ditto + alias getSAnimate = _get!(Tag.sAnimate); + + /++ + + +/ + alias sBlockPickRequest = _create!(Tag.sBlockPickRequest); + /// ditto + pragma(inline, true) bool isSBlockPickRequest() const => _tag == Tag.sBlockPickRequest; + ///ditto + alias getSBlockPickRequest = _get!(Tag.sBlockPickRequest); + + /++ + + +/ + alias sClientCacheBlobStatus = _create!(Tag.sClientCacheBlobStatus); + /// ditto + pragma(inline, true) bool isSClientCacheBlobStatus() const => _tag == Tag.sClientCacheBlobStatus; + ///ditto + alias getSClientCacheBlobStatus = _get!(Tag.sClientCacheBlobStatus); + + /++ + + +/ + alias sClientCacheStatus = _create!(Tag.sClientCacheStatus); + /// ditto + pragma(inline, true) bool isSClientCacheStatus() const => _tag == Tag.sClientCacheStatus; + ///ditto + alias getSClientCacheStatus = _get!(Tag.sClientCacheStatus); + + /++ + + +/ + alias sCommandRequest = _create!(Tag.sCommandRequest); + /// ditto + pragma(inline, true) bool isSCommandRequest() const => _tag == Tag.sCommandRequest; + ///ditto + alias getSCommandRequest = _get!(Tag.sCommandRequest); + + /++ + + +/ + alias sContainerClose = _create!(Tag.sContainerClose); + /// ditto + pragma(inline, true) bool isSContainerClose() const => _tag == Tag.sContainerClose; + ///ditto + alias getSContainerClose = _get!(Tag.sContainerClose); + + /++ + + +/ + alias sEmote = _create!(Tag.sEmote); + /// ditto + pragma(inline, true) bool isSEmote() const => _tag == Tag.sEmote; + ///ditto + alias getSEmote = _get!(Tag.sEmote); + + /++ + + +/ + alias sEmoteList = _create!(Tag.sEmoteList); + /// ditto + pragma(inline, true) bool isSEmoteList() const => _tag == Tag.sEmoteList; + ///ditto + alias getSEmoteList = _get!(Tag.sEmoteList); + + /++ + + +/ + alias sInteract = _create!(Tag.sInteract); + /// ditto + pragma(inline, true) bool isSInteract() const => _tag == Tag.sInteract; + ///ditto + alias getSInteract = _get!(Tag.sInteract); + + /++ + + +/ + alias sInventoryTransaction = _create!(Tag.sInventoryTransaction); + /// ditto + pragma(inline, true) bool isSInventoryTransaction() const => _tag == Tag.sInventoryTransaction; + ///ditto + alias getSInventoryTransaction = _get!(Tag.sInventoryTransaction); + + /++ + + +/ + alias sItemStackRequest = _create!(Tag.sItemStackRequest); + /// ditto + pragma(inline, true) bool isSItemStackRequest() const => _tag == Tag.sItemStackRequest; + ///ditto + alias getSItemStackRequest = _get!(Tag.sItemStackRequest); + + /++ + + +/ + alias sLoadingScreen = _create!(Tag.sLoadingScreen); + /// ditto + pragma(inline, true) bool isSLoadingScreen() const => _tag == Tag.sLoadingScreen; + ///ditto + alias getSLoadingScreen = _get!(Tag.sLoadingScreen); + + /++ + + +/ + alias sLogin = _create!(Tag.sLogin); + /// ditto + pragma(inline, true) bool isSLogin() const => _tag == Tag.sLogin; + ///ditto + alias getSLogin = _get!(Tag.sLogin); + + /++ + + +/ + alias sMobEquipment = _create!(Tag.sMobEquipment); + /// ditto + pragma(inline, true) bool isSMobEquipment() const => _tag == Tag.sMobEquipment; + ///ditto + alias getSMobEquipment = _get!(Tag.sMobEquipment); + + /++ + + +/ + alias sModalFormResponse = _create!(Tag.sModalFormResponse); + /// ditto + pragma(inline, true) bool isSModalFormResponse() const => _tag == Tag.sModalFormResponse; + ///ditto + alias getSModalFormResponse = _get!(Tag.sModalFormResponse); + + /++ + + +/ + alias sPacketViolationWarning = _create!(Tag.sPacketViolationWarning); + /// ditto + pragma(inline, true) bool isSPacketViolationWarning() const => _tag == Tag.sPacketViolationWarning; + ///ditto + alias getSPacketViolationWarning = _get!(Tag.sPacketViolationWarning); + + /++ + + +/ + alias sPlayerAction = _create!(Tag.sPlayerAction); + /// ditto + pragma(inline, true) bool isSPlayerAction() const => _tag == Tag.sPlayerAction; + ///ditto + alias getSPlayerAction = _get!(Tag.sPlayerAction); + + /++ + + +/ + alias sPlayerAuthInput = _create!(Tag.sPlayerAuthInput); + /// ditto + pragma(inline, true) bool isSPlayerAuthInput() const => _tag == Tag.sPlayerAuthInput; + ///ditto + alias getSPlayerAuthInput = _get!(Tag.sPlayerAuthInput); + + /++ + + +/ + alias sPlayerHotbar = _create!(Tag.sPlayerHotbar); + /// ditto + pragma(inline, true) bool isSPlayerHotbar() const => _tag == Tag.sPlayerHotbar; + ///ditto + alias getSPlayerHotbar = _get!(Tag.sPlayerHotbar); + + /++ + + +/ + alias sRequestAbility = _create!(Tag.sRequestAbility); + /// ditto + pragma(inline, true) bool isSRequestAbility() const => _tag == Tag.sRequestAbility; + ///ditto + alias getSRequestAbility = _get!(Tag.sRequestAbility); + + /++ + + +/ + alias sRequestChunkRadius = _create!(Tag.sRequestChunkRadius); + /// ditto + pragma(inline, true) bool isSRequestChunkRadius() const => _tag == Tag.sRequestChunkRadius; + ///ditto + alias getSRequestChunkRadius = _get!(Tag.sRequestChunkRadius); + + /++ + + +/ + alias sRequestNetworkSettings = _create!(Tag.sRequestNetworkSettings); + /// ditto + pragma(inline, true) bool isSRequestNetworkSettings() const => _tag == Tag.sRequestNetworkSettings; + ///ditto + alias getSRequestNetworkSettings = _get!(Tag.sRequestNetworkSettings); + + /++ + + +/ + alias sResourcePackClientResponse = _create!(Tag.sResourcePackClientResponse); + /// ditto + pragma(inline, true) bool isSResourcePackClientResponse() const => _tag == Tag.sResourcePackClientResponse; + ///ditto + alias getSResourcePackClientResponse = _get!(Tag.sResourcePackClientResponse); + + /++ + + +/ + alias sRespawn = _create!(Tag.sRespawn); + /// ditto + pragma(inline, true) bool isSRespawn() const => _tag == Tag.sRespawn; + ///ditto + alias getSRespawn = _get!(Tag.sRespawn); + + /++ + + +/ + alias sSetLocalPlayerAsInitialized = _create!(Tag.sSetLocalPlayerAsInitialized); + /// ditto + pragma(inline, true) bool isSSetLocalPlayerAsInitialized() const => _tag == Tag.sSetLocalPlayerAsInitialized; + ///ditto + alias getSSetLocalPlayerAsInitialized = _get!(Tag.sSetLocalPlayerAsInitialized); + + /++ + + +/ + alias sSetPlayerInventoryOptions = _create!(Tag.sSetPlayerInventoryOptions); + /// ditto + pragma(inline, true) bool isSSetPlayerInventoryOptions() const => _tag == Tag.sSetPlayerInventoryOptions; + ///ditto + alias getSSetPlayerInventoryOptions = _get!(Tag.sSetPlayerInventoryOptions); + + /++ + + +/ + alias sText = _create!(Tag.sText); + /// ditto + pragma(inline, true) bool isSText() const => _tag == Tag.sText; + ///ditto + alias getSText = _get!(Tag.sText); + + /++ + + +/ + alias unknown = _create!(Tag.unknown); + /// ditto + pragma(inline, true) bool isUnknown() const => _tag == Tag.unknown; + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case sClientCacheBlobStatus: _get!(Tag.sClientCacheBlobStatus).witFree; break; + case sCommandRequest: _get!(Tag.sCommandRequest).witFree; break; + case sEmote: _get!(Tag.sEmote).witFree; break; + case sEmoteList: _get!(Tag.sEmoteList).witFree; break; + case sInventoryTransaction: _get!(Tag.sInventoryTransaction).witFree; break; + case sItemStackRequest: _get!(Tag.sItemStackRequest).witFree; break; + case sLogin: _get!(Tag.sLogin).witFree; break; + case sMobEquipment: _get!(Tag.sMobEquipment).witFree; break; + case sModalFormResponse: _get!(Tag.sModalFormResponse).witFree; break; + case sPacketViolationWarning: _get!(Tag.sPacketViolationWarning).witFree; break; + case sPlayerAuthInput: _get!(Tag.sPlayerAuthInput).witFree; break; + case sResourcePackClientResponse: _get!(Tag.sResourcePackClientResponse).witFree; break; + case sText: _get!(Tag.sText).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + } + + ServerboundPacket witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.sActorEvent: return _create!(Tag.sActorEvent)(this._get!(Tag.sActorEvent).witClone); break; + case Tag.sAnimate: return _create!(Tag.sAnimate)(this._get!(Tag.sAnimate).witClone); break; + case Tag.sBlockPickRequest: return _create!(Tag.sBlockPickRequest)(this._get!(Tag.sBlockPickRequest).witClone); break; + case Tag.sClientCacheBlobStatus: return _create!(Tag.sClientCacheBlobStatus)(this._get!(Tag.sClientCacheBlobStatus).witClone); break; + case Tag.sClientCacheStatus: return _create!(Tag.sClientCacheStatus)(this._get!(Tag.sClientCacheStatus).witClone); break; + case Tag.sCommandRequest: return _create!(Tag.sCommandRequest)(this._get!(Tag.sCommandRequest).witClone); break; + case Tag.sContainerClose: return _create!(Tag.sContainerClose)(this._get!(Tag.sContainerClose).witClone); break; + case Tag.sEmote: return _create!(Tag.sEmote)(this._get!(Tag.sEmote).witClone); break; + case Tag.sEmoteList: return _create!(Tag.sEmoteList)(this._get!(Tag.sEmoteList).witClone); break; + case Tag.sInteract: return _create!(Tag.sInteract)(this._get!(Tag.sInteract).witClone); break; + case Tag.sInventoryTransaction: return _create!(Tag.sInventoryTransaction)(this._get!(Tag.sInventoryTransaction).witClone); break; + case Tag.sItemStackRequest: return _create!(Tag.sItemStackRequest)(this._get!(Tag.sItemStackRequest).witClone); break; + case Tag.sLoadingScreen: return _create!(Tag.sLoadingScreen)(this._get!(Tag.sLoadingScreen).witClone); break; + case Tag.sLogin: return _create!(Tag.sLogin)(this._get!(Tag.sLogin).witClone); break; + case Tag.sMobEquipment: return _create!(Tag.sMobEquipment)(this._get!(Tag.sMobEquipment).witClone); break; + case Tag.sModalFormResponse: return _create!(Tag.sModalFormResponse)(this._get!(Tag.sModalFormResponse).witClone); break; + case Tag.sPacketViolationWarning: return _create!(Tag.sPacketViolationWarning)(this._get!(Tag.sPacketViolationWarning).witClone); break; + case Tag.sPlayerAction: return _create!(Tag.sPlayerAction)(this._get!(Tag.sPlayerAction).witClone); break; + case Tag.sPlayerAuthInput: return _create!(Tag.sPlayerAuthInput)(this._get!(Tag.sPlayerAuthInput).witClone); break; + case Tag.sPlayerHotbar: return _create!(Tag.sPlayerHotbar)(this._get!(Tag.sPlayerHotbar).witClone); break; + case Tag.sRequestAbility: return _create!(Tag.sRequestAbility)(this._get!(Tag.sRequestAbility).witClone); break; + case Tag.sRequestChunkRadius: return _create!(Tag.sRequestChunkRadius)(this._get!(Tag.sRequestChunkRadius).witClone); break; + case Tag.sRequestNetworkSettings: return _create!(Tag.sRequestNetworkSettings)(this._get!(Tag.sRequestNetworkSettings).witClone); break; + case Tag.sResourcePackClientResponse: return _create!(Tag.sResourcePackClientResponse)(this._get!(Tag.sResourcePackClientResponse).witClone); break; + case Tag.sRespawn: return _create!(Tag.sRespawn)(this._get!(Tag.sRespawn).witClone); break; + case Tag.sSetLocalPlayerAsInitialized: return _create!(Tag.sSetLocalPlayerAsInitialized)(this._get!(Tag.sSetLocalPlayerAsInitialized).witClone); break; + case Tag.sSetPlayerInventoryOptions: return _create!(Tag.sSetPlayerInventoryOptions)(this._get!(Tag.sSetPlayerInventoryOptions).witClone); break; + case Tag.sText: return _create!(Tag.sText)(this._get!(Tag.sText).witClone); break; + case Tag.unknown: return _create!(Tag.unknown); break; + } + } +} + +/++ + ++/ +struct ClientboundPacket { + mixin WitVariant!( + CAddActor, // cAddActor + CAddItemActor, // cAddItemActor + CAddPlayer, // cAddPlayer + CAvailableCommands, // cAvailableCommands + void, // cBiomeDefinitionList + CBlockActorData, // cBlockActorData + CBlockEvent, // cBlockEvent + CBossEvent, // cBossEvent + CChangeDimension, // cChangeDimension + CChunkRadiusUpdated, // cChunkRadiusUpdated + CClientCacheMissResponse, // cClientCacheMissResponse + CContainerOpen, // cContainerOpen + CCorrectPlayerMovePrediction, // cCorrectPlayerMovePrediction + CCraftingData, // cCraftingData + CCreativeContent, // cCreativeContent + CDisconnect, // cDisconnect + CGamerulesChanged, // cGamerulesChanged + CInventoryContent, // cInventoryContent + CInventorySlot, // cInventorySlot + CItemRegistry, // cItemRegistry + CItemStackResponse, // cItemStackResponse + CLevelChunk, // cLevelChunk + CLevelEvent, // cLevelEvent + CLevelSoundEvent, // cLevelSoundEvent + CMobEffect, // cMobEffect + CMobEquipment, // cMobEquipment + CModalFormRequest, // cModalFormRequest + CMoveActorAbsolute, // cMoveActorAbsolute + CMoveActorDelta, // cMoveActorDelta + CMovePlayer, // cMovePlayer + CNetworkChunkPublisherUpdate, // cNetworkChunkPublisherUpdate + CNetworkSettings, // cNetworkSettings + CPlayStatus, // cPlayStatus + CPlayerHotbar, // cPlayerHotbar + CPlayerList, // cPlayerList + CRemoveActor, // cRemoveActor + CRemoveObjective, // cRemoveObjective + CResourcePackStackPacket, // cResourcePackStackPacket + CResourcePacksInfo, // cResourcePacksInfo + CSetActorData, // cSetActorData + CSetActorLink, // cSetActorLink + CSetActorMotion, // cSetActorMotion + CSetDifficulty, // cSetDifficulty + CSetDisplayObjective, // cSetDisplayObjective + CSetHealth, // cSetHealth + CSetPlayerGameType, // cSetPlayerGameType + CSetScore, // cSetScore + CSetSpawnPosition, // cSetSpawnPosition + CSetTime, // cSetTime + CSetTitle, // cSetTitle + CShowCredits, // cShowCredits + CStartGame, // cStartGame + CTakeItemActor, // cTakeItemActor + CTransfer, // cTransfer + CUpdateAbilities, // cUpdateAbilities + CUpdateAttributes, // cUpdateAttributes + CUpdateBlock, // cUpdateBlock + CUpdateTrade, // cUpdateTrade + void, // unknown + ); + +public: + enum Tag : ubyte { + /++ + + +/ + cAddActor, + + /++ + + +/ + cAddItemActor, + + /++ + + +/ + cAddPlayer, + + /++ + + +/ + cAvailableCommands, + + /++ + + +/ + cBiomeDefinitionList, + + /++ + + +/ + cBlockActorData, + + /++ + + +/ + cBlockEvent, + + /++ + + +/ + cBossEvent, + + /++ + + +/ + cChangeDimension, + + /++ + + +/ + cChunkRadiusUpdated, + + /++ + + +/ + cClientCacheMissResponse, + + /++ + + +/ + cContainerOpen, + + /++ + + +/ + cCorrectPlayerMovePrediction, + + /++ + + +/ + cCraftingData, + + /++ + + +/ + cCreativeContent, + + /++ + + +/ + cDisconnect, + + /++ + + +/ + cGamerulesChanged, + + /++ + + +/ + cInventoryContent, + + /++ + + +/ + cInventorySlot, + + /++ + + +/ + cItemRegistry, + + /++ + + +/ + cItemStackResponse, + + /++ + + +/ + cLevelChunk, + + /++ + + +/ + cLevelEvent, + + /++ + + +/ + cLevelSoundEvent, + + /++ + + +/ + cMobEffect, + + /++ + + +/ + cMobEquipment, + + /++ + + +/ + cModalFormRequest, + + /++ + + +/ + cMoveActorAbsolute, + + /++ + + +/ + cMoveActorDelta, + + /++ + + +/ + cMovePlayer, + + /++ + + +/ + cNetworkChunkPublisherUpdate, + + /++ + + +/ + cNetworkSettings, + + /++ + + +/ + cPlayStatus, + + /++ + + +/ + cPlayerHotbar, + + /++ + + +/ + cPlayerList, + + /++ + + +/ + cRemoveActor, + + /++ + + +/ + cRemoveObjective, + + /++ + + +/ + cResourcePackStackPacket, + + /++ + + +/ + cResourcePacksInfo, + + /++ + + +/ + cSetActorData, + + /++ + + +/ + cSetActorLink, + + /++ + + +/ + cSetActorMotion, + + /++ + + +/ + cSetDifficulty, + + /++ + + +/ + cSetDisplayObjective, + + /++ + + +/ + cSetHealth, + + /++ + + +/ + cSetPlayerGameType, + + /++ + + +/ + cSetScore, + + /++ + + +/ + cSetSpawnPosition, + + /++ + + +/ + cSetTime, + + /++ + + +/ + cSetTitle, + + /++ + + +/ + cShowCredits, + + /++ + + +/ + cStartGame, + + /++ + + +/ + cTakeItemActor, + + /++ + + +/ + cTransfer, + + /++ + + +/ + cUpdateAbilities, + + /++ + + +/ + cUpdateAttributes, + + /++ + + +/ + cUpdateBlock, + + /++ + + +/ + cUpdateTrade, + + /++ + + +/ + unknown, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias cAddActor = _create!(Tag.cAddActor); + /// ditto + pragma(inline, true) bool isCAddActor() const => _tag == Tag.cAddActor; + ///ditto + alias getCAddActor = _get!(Tag.cAddActor); + + /++ + + +/ + alias cAddItemActor = _create!(Tag.cAddItemActor); + /// ditto + pragma(inline, true) bool isCAddItemActor() const => _tag == Tag.cAddItemActor; + ///ditto + alias getCAddItemActor = _get!(Tag.cAddItemActor); + + /++ + + +/ + alias cAddPlayer = _create!(Tag.cAddPlayer); + /// ditto + pragma(inline, true) bool isCAddPlayer() const => _tag == Tag.cAddPlayer; + ///ditto + alias getCAddPlayer = _get!(Tag.cAddPlayer); + + /++ + + +/ + alias cAvailableCommands = _create!(Tag.cAvailableCommands); + /// ditto + pragma(inline, true) bool isCAvailableCommands() const => _tag == Tag.cAvailableCommands; + ///ditto + alias getCAvailableCommands = _get!(Tag.cAvailableCommands); + + /++ + + +/ + alias cBiomeDefinitionList = _create!(Tag.cBiomeDefinitionList); + /// ditto + pragma(inline, true) bool isCBiomeDefinitionList() const => _tag == Tag.cBiomeDefinitionList; + + /++ + + +/ + alias cBlockActorData = _create!(Tag.cBlockActorData); + /// ditto + pragma(inline, true) bool isCBlockActorData() const => _tag == Tag.cBlockActorData; + ///ditto + alias getCBlockActorData = _get!(Tag.cBlockActorData); + + /++ + + +/ + alias cBlockEvent = _create!(Tag.cBlockEvent); + /// ditto + pragma(inline, true) bool isCBlockEvent() const => _tag == Tag.cBlockEvent; + ///ditto + alias getCBlockEvent = _get!(Tag.cBlockEvent); + + /++ + + +/ + alias cBossEvent = _create!(Tag.cBossEvent); + /// ditto + pragma(inline, true) bool isCBossEvent() const => _tag == Tag.cBossEvent; + ///ditto + alias getCBossEvent = _get!(Tag.cBossEvent); + + /++ + + +/ + alias cChangeDimension = _create!(Tag.cChangeDimension); + /// ditto + pragma(inline, true) bool isCChangeDimension() const => _tag == Tag.cChangeDimension; + ///ditto + alias getCChangeDimension = _get!(Tag.cChangeDimension); + + /++ + + +/ + alias cChunkRadiusUpdated = _create!(Tag.cChunkRadiusUpdated); + /// ditto + pragma(inline, true) bool isCChunkRadiusUpdated() const => _tag == Tag.cChunkRadiusUpdated; + ///ditto + alias getCChunkRadiusUpdated = _get!(Tag.cChunkRadiusUpdated); + + /++ + + +/ + alias cClientCacheMissResponse = _create!(Tag.cClientCacheMissResponse); + /// ditto + pragma(inline, true) bool isCClientCacheMissResponse() const => _tag == Tag.cClientCacheMissResponse; + ///ditto + alias getCClientCacheMissResponse = _get!(Tag.cClientCacheMissResponse); + + /++ + + +/ + alias cContainerOpen = _create!(Tag.cContainerOpen); + /// ditto + pragma(inline, true) bool isCContainerOpen() const => _tag == Tag.cContainerOpen; + ///ditto + alias getCContainerOpen = _get!(Tag.cContainerOpen); + + /++ + + +/ + alias cCorrectPlayerMovePrediction = _create!(Tag.cCorrectPlayerMovePrediction); + /// ditto + pragma(inline, true) bool isCCorrectPlayerMovePrediction() const => _tag == Tag.cCorrectPlayerMovePrediction; + ///ditto + alias getCCorrectPlayerMovePrediction = _get!(Tag.cCorrectPlayerMovePrediction); + + /++ + + +/ + alias cCraftingData = _create!(Tag.cCraftingData); + /// ditto + pragma(inline, true) bool isCCraftingData() const => _tag == Tag.cCraftingData; + ///ditto + alias getCCraftingData = _get!(Tag.cCraftingData); + + /++ + + +/ + alias cCreativeContent = _create!(Tag.cCreativeContent); + /// ditto + pragma(inline, true) bool isCCreativeContent() const => _tag == Tag.cCreativeContent; + ///ditto + alias getCCreativeContent = _get!(Tag.cCreativeContent); + + /++ + + +/ + alias cDisconnect = _create!(Tag.cDisconnect); + /// ditto + pragma(inline, true) bool isCDisconnect() const => _tag == Tag.cDisconnect; + ///ditto + alias getCDisconnect = _get!(Tag.cDisconnect); + + /++ + + +/ + alias cGamerulesChanged = _create!(Tag.cGamerulesChanged); + /// ditto + pragma(inline, true) bool isCGamerulesChanged() const => _tag == Tag.cGamerulesChanged; + ///ditto + alias getCGamerulesChanged = _get!(Tag.cGamerulesChanged); + + /++ + + +/ + alias cInventoryContent = _create!(Tag.cInventoryContent); + /// ditto + pragma(inline, true) bool isCInventoryContent() const => _tag == Tag.cInventoryContent; + ///ditto + alias getCInventoryContent = _get!(Tag.cInventoryContent); + + /++ + + +/ + alias cInventorySlot = _create!(Tag.cInventorySlot); + /// ditto + pragma(inline, true) bool isCInventorySlot() const => _tag == Tag.cInventorySlot; + ///ditto + alias getCInventorySlot = _get!(Tag.cInventorySlot); + + /++ + + +/ + alias cItemRegistry = _create!(Tag.cItemRegistry); + /// ditto + pragma(inline, true) bool isCItemRegistry() const => _tag == Tag.cItemRegistry; + ///ditto + alias getCItemRegistry = _get!(Tag.cItemRegistry); + + /++ + + +/ + alias cItemStackResponse = _create!(Tag.cItemStackResponse); + /// ditto + pragma(inline, true) bool isCItemStackResponse() const => _tag == Tag.cItemStackResponse; + ///ditto + alias getCItemStackResponse = _get!(Tag.cItemStackResponse); + + /++ + + +/ + alias cLevelChunk = _create!(Tag.cLevelChunk); + /// ditto + pragma(inline, true) bool isCLevelChunk() const => _tag == Tag.cLevelChunk; + ///ditto + alias getCLevelChunk = _get!(Tag.cLevelChunk); + + /++ + + +/ + alias cLevelEvent = _create!(Tag.cLevelEvent); + /// ditto + pragma(inline, true) bool isCLevelEvent() const => _tag == Tag.cLevelEvent; + ///ditto + alias getCLevelEvent = _get!(Tag.cLevelEvent); + + /++ + + +/ + alias cLevelSoundEvent = _create!(Tag.cLevelSoundEvent); + /// ditto + pragma(inline, true) bool isCLevelSoundEvent() const => _tag == Tag.cLevelSoundEvent; + ///ditto + alias getCLevelSoundEvent = _get!(Tag.cLevelSoundEvent); + + /++ + + +/ + alias cMobEffect = _create!(Tag.cMobEffect); + /// ditto + pragma(inline, true) bool isCMobEffect() const => _tag == Tag.cMobEffect; + ///ditto + alias getCMobEffect = _get!(Tag.cMobEffect); + + /++ + + +/ + alias cMobEquipment = _create!(Tag.cMobEquipment); + /// ditto + pragma(inline, true) bool isCMobEquipment() const => _tag == Tag.cMobEquipment; + ///ditto + alias getCMobEquipment = _get!(Tag.cMobEquipment); + + /++ + + +/ + alias cModalFormRequest = _create!(Tag.cModalFormRequest); + /// ditto + pragma(inline, true) bool isCModalFormRequest() const => _tag == Tag.cModalFormRequest; + ///ditto + alias getCModalFormRequest = _get!(Tag.cModalFormRequest); + + /++ + + +/ + alias cMoveActorAbsolute = _create!(Tag.cMoveActorAbsolute); + /// ditto + pragma(inline, true) bool isCMoveActorAbsolute() const => _tag == Tag.cMoveActorAbsolute; + ///ditto + alias getCMoveActorAbsolute = _get!(Tag.cMoveActorAbsolute); + + /++ + + +/ + alias cMoveActorDelta = _create!(Tag.cMoveActorDelta); + /// ditto + pragma(inline, true) bool isCMoveActorDelta() const => _tag == Tag.cMoveActorDelta; + ///ditto + alias getCMoveActorDelta = _get!(Tag.cMoveActorDelta); + + /++ + + +/ + alias cMovePlayer = _create!(Tag.cMovePlayer); + /// ditto + pragma(inline, true) bool isCMovePlayer() const => _tag == Tag.cMovePlayer; + ///ditto + alias getCMovePlayer = _get!(Tag.cMovePlayer); + + /++ + + +/ + alias cNetworkChunkPublisherUpdate = _create!(Tag.cNetworkChunkPublisherUpdate); + /// ditto + pragma(inline, true) bool isCNetworkChunkPublisherUpdate() const => _tag == Tag.cNetworkChunkPublisherUpdate; + ///ditto + alias getCNetworkChunkPublisherUpdate = _get!(Tag.cNetworkChunkPublisherUpdate); + + /++ + + +/ + alias cNetworkSettings = _create!(Tag.cNetworkSettings); + /// ditto + pragma(inline, true) bool isCNetworkSettings() const => _tag == Tag.cNetworkSettings; + ///ditto + alias getCNetworkSettings = _get!(Tag.cNetworkSettings); + + /++ + + +/ + alias cPlayStatus = _create!(Tag.cPlayStatus); + /// ditto + pragma(inline, true) bool isCPlayStatus() const => _tag == Tag.cPlayStatus; + ///ditto + alias getCPlayStatus = _get!(Tag.cPlayStatus); + + /++ + + +/ + alias cPlayerHotbar = _create!(Tag.cPlayerHotbar); + /// ditto + pragma(inline, true) bool isCPlayerHotbar() const => _tag == Tag.cPlayerHotbar; + ///ditto + alias getCPlayerHotbar = _get!(Tag.cPlayerHotbar); + + /++ + + +/ + alias cPlayerList = _create!(Tag.cPlayerList); + /// ditto + pragma(inline, true) bool isCPlayerList() const => _tag == Tag.cPlayerList; + ///ditto + alias getCPlayerList = _get!(Tag.cPlayerList); + + /++ + + +/ + alias cRemoveActor = _create!(Tag.cRemoveActor); + /// ditto + pragma(inline, true) bool isCRemoveActor() const => _tag == Tag.cRemoveActor; + ///ditto + alias getCRemoveActor = _get!(Tag.cRemoveActor); + + /++ + + +/ + alias cRemoveObjective = _create!(Tag.cRemoveObjective); + /// ditto + pragma(inline, true) bool isCRemoveObjective() const => _tag == Tag.cRemoveObjective; + ///ditto + alias getCRemoveObjective = _get!(Tag.cRemoveObjective); + + /++ + + +/ + alias cResourcePackStackPacket = _create!(Tag.cResourcePackStackPacket); + /// ditto + pragma(inline, true) bool isCResourcePackStackPacket() const => _tag == Tag.cResourcePackStackPacket; + ///ditto + alias getCResourcePackStackPacket = _get!(Tag.cResourcePackStackPacket); + + /++ + + +/ + alias cResourcePacksInfo = _create!(Tag.cResourcePacksInfo); + /// ditto + pragma(inline, true) bool isCResourcePacksInfo() const => _tag == Tag.cResourcePacksInfo; + ///ditto + alias getCResourcePacksInfo = _get!(Tag.cResourcePacksInfo); + + /++ + + +/ + alias cSetActorData = _create!(Tag.cSetActorData); + /// ditto + pragma(inline, true) bool isCSetActorData() const => _tag == Tag.cSetActorData; + ///ditto + alias getCSetActorData = _get!(Tag.cSetActorData); + + /++ + + +/ + alias cSetActorLink = _create!(Tag.cSetActorLink); + /// ditto + pragma(inline, true) bool isCSetActorLink() const => _tag == Tag.cSetActorLink; + ///ditto + alias getCSetActorLink = _get!(Tag.cSetActorLink); + + /++ + + +/ + alias cSetActorMotion = _create!(Tag.cSetActorMotion); + /// ditto + pragma(inline, true) bool isCSetActorMotion() const => _tag == Tag.cSetActorMotion; + ///ditto + alias getCSetActorMotion = _get!(Tag.cSetActorMotion); + + /++ + + +/ + alias cSetDifficulty = _create!(Tag.cSetDifficulty); + /// ditto + pragma(inline, true) bool isCSetDifficulty() const => _tag == Tag.cSetDifficulty; + ///ditto + alias getCSetDifficulty = _get!(Tag.cSetDifficulty); + + /++ + + +/ + alias cSetDisplayObjective = _create!(Tag.cSetDisplayObjective); + /// ditto + pragma(inline, true) bool isCSetDisplayObjective() const => _tag == Tag.cSetDisplayObjective; + ///ditto + alias getCSetDisplayObjective = _get!(Tag.cSetDisplayObjective); + + /++ + + +/ + alias cSetHealth = _create!(Tag.cSetHealth); + /// ditto + pragma(inline, true) bool isCSetHealth() const => _tag == Tag.cSetHealth; + ///ditto + alias getCSetHealth = _get!(Tag.cSetHealth); + + /++ + + +/ + alias cSetPlayerGameType = _create!(Tag.cSetPlayerGameType); + /// ditto + pragma(inline, true) bool isCSetPlayerGameType() const => _tag == Tag.cSetPlayerGameType; + ///ditto + alias getCSetPlayerGameType = _get!(Tag.cSetPlayerGameType); + + /++ + + +/ + alias cSetScore = _create!(Tag.cSetScore); + /// ditto + pragma(inline, true) bool isCSetScore() const => _tag == Tag.cSetScore; + ///ditto + alias getCSetScore = _get!(Tag.cSetScore); + + /++ + + +/ + alias cSetSpawnPosition = _create!(Tag.cSetSpawnPosition); + /// ditto + pragma(inline, true) bool isCSetSpawnPosition() const => _tag == Tag.cSetSpawnPosition; + ///ditto + alias getCSetSpawnPosition = _get!(Tag.cSetSpawnPosition); + + /++ + + +/ + alias cSetTime = _create!(Tag.cSetTime); + /// ditto + pragma(inline, true) bool isCSetTime() const => _tag == Tag.cSetTime; + ///ditto + alias getCSetTime = _get!(Tag.cSetTime); + + /++ + + +/ + alias cSetTitle = _create!(Tag.cSetTitle); + /// ditto + pragma(inline, true) bool isCSetTitle() const => _tag == Tag.cSetTitle; + ///ditto + alias getCSetTitle = _get!(Tag.cSetTitle); + + /++ + + +/ + alias cShowCredits = _create!(Tag.cShowCredits); + /// ditto + pragma(inline, true) bool isCShowCredits() const => _tag == Tag.cShowCredits; + ///ditto + alias getCShowCredits = _get!(Tag.cShowCredits); + + /++ + + +/ + alias cStartGame = _create!(Tag.cStartGame); + /// ditto + pragma(inline, true) bool isCStartGame() const => _tag == Tag.cStartGame; + ///ditto + alias getCStartGame = _get!(Tag.cStartGame); + + /++ + + +/ + alias cTakeItemActor = _create!(Tag.cTakeItemActor); + /// ditto + pragma(inline, true) bool isCTakeItemActor() const => _tag == Tag.cTakeItemActor; + ///ditto + alias getCTakeItemActor = _get!(Tag.cTakeItemActor); + + /++ + + +/ + alias cTransfer = _create!(Tag.cTransfer); + /// ditto + pragma(inline, true) bool isCTransfer() const => _tag == Tag.cTransfer; + ///ditto + alias getCTransfer = _get!(Tag.cTransfer); + + /++ + + +/ + alias cUpdateAbilities = _create!(Tag.cUpdateAbilities); + /// ditto + pragma(inline, true) bool isCUpdateAbilities() const => _tag == Tag.cUpdateAbilities; + ///ditto + alias getCUpdateAbilities = _get!(Tag.cUpdateAbilities); + + /++ + + +/ + alias cUpdateAttributes = _create!(Tag.cUpdateAttributes); + /// ditto + pragma(inline, true) bool isCUpdateAttributes() const => _tag == Tag.cUpdateAttributes; + ///ditto + alias getCUpdateAttributes = _get!(Tag.cUpdateAttributes); + + /++ + + +/ + alias cUpdateBlock = _create!(Tag.cUpdateBlock); + /// ditto + pragma(inline, true) bool isCUpdateBlock() const => _tag == Tag.cUpdateBlock; + ///ditto + alias getCUpdateBlock = _get!(Tag.cUpdateBlock); + + /++ + + +/ + alias cUpdateTrade = _create!(Tag.cUpdateTrade); + /// ditto + pragma(inline, true) bool isCUpdateTrade() const => _tag == Tag.cUpdateTrade; + ///ditto + alias getCUpdateTrade = _get!(Tag.cUpdateTrade); + + /++ + + +/ + alias unknown = _create!(Tag.unknown); + /// ditto + pragma(inline, true) bool isUnknown() const => _tag == Tag.unknown; + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case cAddActor: _get!(Tag.cAddActor).witFree; break; + case cAddItemActor: _get!(Tag.cAddItemActor).witFree; break; + case cAddPlayer: _get!(Tag.cAddPlayer).witFree; break; + case cAvailableCommands: _get!(Tag.cAvailableCommands).witFree; break; + case cBlockActorData: _get!(Tag.cBlockActorData).witFree; break; + case cBossEvent: _get!(Tag.cBossEvent).witFree; break; + case cClientCacheMissResponse: _get!(Tag.cClientCacheMissResponse).witFree; break; + case cCraftingData: _get!(Tag.cCraftingData).witFree; break; + case cCreativeContent: _get!(Tag.cCreativeContent).witFree; break; + case cDisconnect: _get!(Tag.cDisconnect).witFree; break; + case cGamerulesChanged: _get!(Tag.cGamerulesChanged).witFree; break; + case cInventoryContent: _get!(Tag.cInventoryContent).witFree; break; + case cInventorySlot: _get!(Tag.cInventorySlot).witFree; break; + case cItemRegistry: _get!(Tag.cItemRegistry).witFree; break; + case cItemStackResponse: _get!(Tag.cItemStackResponse).witFree; break; + case cLevelChunk: _get!(Tag.cLevelChunk).witFree; break; + case cLevelSoundEvent: _get!(Tag.cLevelSoundEvent).witFree; break; + case cMobEquipment: _get!(Tag.cMobEquipment).witFree; break; + case cModalFormRequest: _get!(Tag.cModalFormRequest).witFree; break; + case cNetworkChunkPublisherUpdate: _get!(Tag.cNetworkChunkPublisherUpdate).witFree; break; + case cPlayerList: _get!(Tag.cPlayerList).witFree; break; + case cRemoveObjective: _get!(Tag.cRemoveObjective).witFree; break; + case cResourcePackStackPacket: _get!(Tag.cResourcePackStackPacket).witFree; break; + case cResourcePacksInfo: _get!(Tag.cResourcePacksInfo).witFree; break; + case cSetActorData: _get!(Tag.cSetActorData).witFree; break; + case cSetDisplayObjective: _get!(Tag.cSetDisplayObjective).witFree; break; + case cSetScore: _get!(Tag.cSetScore).witFree; break; + case cSetTitle: _get!(Tag.cSetTitle).witFree; break; + case cStartGame: _get!(Tag.cStartGame).witFree; break; + case cTransfer: _get!(Tag.cTransfer).witFree; break; + case cUpdateAbilities: _get!(Tag.cUpdateAbilities).witFree; break; + case cUpdateAttributes: _get!(Tag.cUpdateAttributes).witFree; break; + case cUpdateTrade: _get!(Tag.cUpdateTrade).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + } + + ClientboundPacket witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.cAddActor: return _create!(Tag.cAddActor)(this._get!(Tag.cAddActor).witClone); break; + case Tag.cAddItemActor: return _create!(Tag.cAddItemActor)(this._get!(Tag.cAddItemActor).witClone); break; + case Tag.cAddPlayer: return _create!(Tag.cAddPlayer)(this._get!(Tag.cAddPlayer).witClone); break; + case Tag.cAvailableCommands: return _create!(Tag.cAvailableCommands)(this._get!(Tag.cAvailableCommands).witClone); break; + case Tag.cBiomeDefinitionList: return _create!(Tag.cBiomeDefinitionList); break; + case Tag.cBlockActorData: return _create!(Tag.cBlockActorData)(this._get!(Tag.cBlockActorData).witClone); break; + case Tag.cBlockEvent: return _create!(Tag.cBlockEvent)(this._get!(Tag.cBlockEvent).witClone); break; + case Tag.cBossEvent: return _create!(Tag.cBossEvent)(this._get!(Tag.cBossEvent).witClone); break; + case Tag.cChangeDimension: return _create!(Tag.cChangeDimension)(this._get!(Tag.cChangeDimension).witClone); break; + case Tag.cChunkRadiusUpdated: return _create!(Tag.cChunkRadiusUpdated)(this._get!(Tag.cChunkRadiusUpdated).witClone); break; + case Tag.cClientCacheMissResponse: return _create!(Tag.cClientCacheMissResponse)(this._get!(Tag.cClientCacheMissResponse).witClone); break; + case Tag.cContainerOpen: return _create!(Tag.cContainerOpen)(this._get!(Tag.cContainerOpen).witClone); break; + case Tag.cCorrectPlayerMovePrediction: return _create!(Tag.cCorrectPlayerMovePrediction)(this._get!(Tag.cCorrectPlayerMovePrediction).witClone); break; + case Tag.cCraftingData: return _create!(Tag.cCraftingData)(this._get!(Tag.cCraftingData).witClone); break; + case Tag.cCreativeContent: return _create!(Tag.cCreativeContent)(this._get!(Tag.cCreativeContent).witClone); break; + case Tag.cDisconnect: return _create!(Tag.cDisconnect)(this._get!(Tag.cDisconnect).witClone); break; + case Tag.cGamerulesChanged: return _create!(Tag.cGamerulesChanged)(this._get!(Tag.cGamerulesChanged).witClone); break; + case Tag.cInventoryContent: return _create!(Tag.cInventoryContent)(this._get!(Tag.cInventoryContent).witClone); break; + case Tag.cInventorySlot: return _create!(Tag.cInventorySlot)(this._get!(Tag.cInventorySlot).witClone); break; + case Tag.cItemRegistry: return _create!(Tag.cItemRegistry)(this._get!(Tag.cItemRegistry).witClone); break; + case Tag.cItemStackResponse: return _create!(Tag.cItemStackResponse)(this._get!(Tag.cItemStackResponse).witClone); break; + case Tag.cLevelChunk: return _create!(Tag.cLevelChunk)(this._get!(Tag.cLevelChunk).witClone); break; + case Tag.cLevelEvent: return _create!(Tag.cLevelEvent)(this._get!(Tag.cLevelEvent).witClone); break; + case Tag.cLevelSoundEvent: return _create!(Tag.cLevelSoundEvent)(this._get!(Tag.cLevelSoundEvent).witClone); break; + case Tag.cMobEffect: return _create!(Tag.cMobEffect)(this._get!(Tag.cMobEffect).witClone); break; + case Tag.cMobEquipment: return _create!(Tag.cMobEquipment)(this._get!(Tag.cMobEquipment).witClone); break; + case Tag.cModalFormRequest: return _create!(Tag.cModalFormRequest)(this._get!(Tag.cModalFormRequest).witClone); break; + case Tag.cMoveActorAbsolute: return _create!(Tag.cMoveActorAbsolute)(this._get!(Tag.cMoveActorAbsolute).witClone); break; + case Tag.cMoveActorDelta: return _create!(Tag.cMoveActorDelta)(this._get!(Tag.cMoveActorDelta).witClone); break; + case Tag.cMovePlayer: return _create!(Tag.cMovePlayer)(this._get!(Tag.cMovePlayer).witClone); break; + case Tag.cNetworkChunkPublisherUpdate: return _create!(Tag.cNetworkChunkPublisherUpdate)(this._get!(Tag.cNetworkChunkPublisherUpdate).witClone); break; + case Tag.cNetworkSettings: return _create!(Tag.cNetworkSettings)(this._get!(Tag.cNetworkSettings).witClone); break; + case Tag.cPlayStatus: return _create!(Tag.cPlayStatus)(this._get!(Tag.cPlayStatus).witClone); break; + case Tag.cPlayerHotbar: return _create!(Tag.cPlayerHotbar)(this._get!(Tag.cPlayerHotbar).witClone); break; + case Tag.cPlayerList: return _create!(Tag.cPlayerList)(this._get!(Tag.cPlayerList).witClone); break; + case Tag.cRemoveActor: return _create!(Tag.cRemoveActor)(this._get!(Tag.cRemoveActor).witClone); break; + case Tag.cRemoveObjective: return _create!(Tag.cRemoveObjective)(this._get!(Tag.cRemoveObjective).witClone); break; + case Tag.cResourcePackStackPacket: return _create!(Tag.cResourcePackStackPacket)(this._get!(Tag.cResourcePackStackPacket).witClone); break; + case Tag.cResourcePacksInfo: return _create!(Tag.cResourcePacksInfo)(this._get!(Tag.cResourcePacksInfo).witClone); break; + case Tag.cSetActorData: return _create!(Tag.cSetActorData)(this._get!(Tag.cSetActorData).witClone); break; + case Tag.cSetActorLink: return _create!(Tag.cSetActorLink)(this._get!(Tag.cSetActorLink).witClone); break; + case Tag.cSetActorMotion: return _create!(Tag.cSetActorMotion)(this._get!(Tag.cSetActorMotion).witClone); break; + case Tag.cSetDifficulty: return _create!(Tag.cSetDifficulty)(this._get!(Tag.cSetDifficulty).witClone); break; + case Tag.cSetDisplayObjective: return _create!(Tag.cSetDisplayObjective)(this._get!(Tag.cSetDisplayObjective).witClone); break; + case Tag.cSetHealth: return _create!(Tag.cSetHealth)(this._get!(Tag.cSetHealth).witClone); break; + case Tag.cSetPlayerGameType: return _create!(Tag.cSetPlayerGameType)(this._get!(Tag.cSetPlayerGameType).witClone); break; + case Tag.cSetScore: return _create!(Tag.cSetScore)(this._get!(Tag.cSetScore).witClone); break; + case Tag.cSetSpawnPosition: return _create!(Tag.cSetSpawnPosition)(this._get!(Tag.cSetSpawnPosition).witClone); break; + case Tag.cSetTime: return _create!(Tag.cSetTime)(this._get!(Tag.cSetTime).witClone); break; + case Tag.cSetTitle: return _create!(Tag.cSetTitle)(this._get!(Tag.cSetTitle).witClone); break; + case Tag.cShowCredits: return _create!(Tag.cShowCredits)(this._get!(Tag.cShowCredits).witClone); break; + case Tag.cStartGame: return _create!(Tag.cStartGame)(this._get!(Tag.cStartGame).witClone); break; + case Tag.cTakeItemActor: return _create!(Tag.cTakeItemActor)(this._get!(Tag.cTakeItemActor).witClone); break; + case Tag.cTransfer: return _create!(Tag.cTransfer)(this._get!(Tag.cTransfer).witClone); break; + case Tag.cUpdateAbilities: return _create!(Tag.cUpdateAbilities)(this._get!(Tag.cUpdateAbilities).witClone); break; + case Tag.cUpdateAttributes: return _create!(Tag.cUpdateAttributes)(this._get!(Tag.cUpdateAttributes).witClone); break; + case Tag.cUpdateBlock: return _create!(Tag.cUpdateBlock)(this._get!(Tag.cUpdateBlock).witClone); break; + case Tag.cUpdateTrade: return _create!(Tag.cUpdateTrade)(this._get!(Tag.cUpdateTrade).witClone); break; + case Tag.unknown: return _create!(Tag.unknown); break; + } + } +} diff --git a/src/wit/pumpkin/plugin/bedrock_packets/imports.d b/src/wit/pumpkin/plugin/bedrock_packets/imports.d new file mode 100644 index 0000000..cee2c68 --- /dev/null +++ b/src/wit/pumpkin/plugin/bedrock_packets/imports.d @@ -0,0 +1,13 @@ +/++ + ++/ +module wit.pumpkin.plugin.bedrock_packets.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.bedrock_packets.common; + +static import wit.pumpkin.plugin.uuid.imports; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); diff --git a/src/wit/pumpkin/plugin/biomes/common.d b/src/wit/pumpkin/plugin/biomes/common.d new file mode 100644 index 0000000..b44944d --- /dev/null +++ b/src/wit/pumpkin/plugin/biomes/common.d @@ -0,0 +1,345 @@ +/++ + ++/ +module wit.pumpkin.plugin.biomes.common; + + +import wit.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +enum Biome : ubyte { + /++ + + +/ + badlands, + + /++ + + +/ + bambooJungle, + + /++ + + +/ + basaltDeltas, + + /++ + + +/ + beach, + + /++ + + +/ + birchForest, + + /++ + + +/ + cherryGrove, + + /++ + + +/ + coldOcean, + + /++ + + +/ + crimsonForest, + + /++ + + +/ + darkForest, + + /++ + + +/ + deepColdOcean, + + /++ + + +/ + deepDark, + + /++ + + +/ + deepFrozenOcean, + + /++ + + +/ + deepLukewarmOcean, + + /++ + + +/ + deepOcean, + + /++ + + +/ + desert, + + /++ + + +/ + dripstoneCaves, + + /++ + + +/ + endBarrens, + + /++ + + +/ + endHighlands, + + /++ + + +/ + endMidlands, + + /++ + + +/ + erodedBadlands, + + /++ + + +/ + flowerForest, + + /++ + + +/ + forest, + + /++ + + +/ + frozenOcean, + + /++ + + +/ + frozenPeaks, + + /++ + + +/ + frozenRiver, + + /++ + + +/ + grove, + + /++ + + +/ + iceSpikes, + + /++ + + +/ + jaggedPeaks, + + /++ + + +/ + jungle, + + /++ + + +/ + lukewarmOcean, + + /++ + + +/ + lushCaves, + + /++ + + +/ + mangroveSwamp, + + /++ + + +/ + meadow, + + /++ + + +/ + mushroomFields, + + /++ + + +/ + netherWastes, + + /++ + + +/ + ocean, + + /++ + + +/ + oldGrowthBirchForest, + + /++ + + +/ + oldGrowthPineTaiga, + + /++ + + +/ + oldGrowthSpruceTaiga, + + /++ + + +/ + paleGarden, + + /++ + + +/ + plains, + + /++ + + +/ + river, + + /++ + + +/ + savanna, + + /++ + + +/ + savannaPlateau, + + /++ + + +/ + smallEndIslands, + + /++ + + +/ + snowyBeach, + + /++ + + +/ + snowyPlains, + + /++ + + +/ + snowySlopes, + + /++ + + +/ + snowyTaiga, + + /++ + + +/ + soulSandValley, + + /++ + + +/ + sparseJungle, + + /++ + + +/ + stonyPeaks, + + /++ + + +/ + stonyShore, + + /++ + + +/ + sulfurCaves, + + /++ + + +/ + sunflowerPlains, + + /++ + + +/ + swamp, + + /++ + + +/ + taiga, + + /++ + + +/ + theEnd, + + /++ + + +/ + theVoid, + + /++ + + +/ + warmOcean, + + /++ + + +/ + warpedForest, + + /++ + + +/ + windsweptForest, + + /++ + + +/ + windsweptGravellyHills, + + /++ + + +/ + windsweptHills, + + /++ + + +/ + windsweptSavanna, + + /++ + + +/ + woodedBadlands, +} \ No newline at end of file diff --git a/src/wit/pumpkin/plugin/biomes/imports.d b/src/wit/pumpkin/plugin/biomes/imports.d new file mode 100644 index 0000000..25434ef --- /dev/null +++ b/src/wit/pumpkin/plugin/biomes/imports.d @@ -0,0 +1,12 @@ +/++ + ++/ +module wit.pumpkin.plugin.biomes.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.biomes.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); diff --git a/src/wit/pumpkin/plugin/block_entity/common.d b/src/wit/pumpkin/plugin/block_entity/common.d new file mode 100644 index 0000000..e915648 --- /dev/null +++ b/src/wit/pumpkin/plugin/block_entity/common.d @@ -0,0 +1,142 @@ +/++ + ++/ +module wit.pumpkin.plugin.block_entity.common; + + +import wit.common; + +static import wit.pumpkin.plugin.common.common; +static import wit.pumpkin.plugin.item_stack.common; +static import wit.pumpkin.plugin.inventory.common; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias BlockPos = wit.pumpkin.plugin.common.common.BlockPos; + +/++ + ++/ +alias NbtTree = wit.pumpkin.plugin.common.common.NbtTree; + +/++ + ++/ +enum DyeColor : ubyte { + /++ + + +/ + white, + + /++ + + +/ + orange, + + /++ + + +/ + magenta, + + /++ + + +/ + lightBlue, + + /++ + + +/ + yellow, + + /++ + + +/ + lime, + + /++ + + +/ + pink, + + /++ + + +/ + gray, + + /++ + + +/ + lightGray, + + /++ + + +/ + cyan, + + /++ + + +/ + purple, + + /++ + + +/ + blue, + + /++ + + +/ + brown, + + /++ + + +/ + green, + + /++ + + +/ + red, + + /++ + + +/ + black, +} +/++ + ++/ +struct SignText { + /++ + + +/ + WitList!(WitString) messages; + + /++ + + +/ + DyeColor color; + + /++ + + +/ + bool hasGlowingText; + + void witFree() @nogc nothrow { + messages.witFree; + } + + void witDrop() @nogc nothrow { + } + + SignText witClone() const @nogc nothrow { + SignText clone = void; + clone.messages = this.messages.witClone; + clone.color = this.color.witClone; + clone.hasGlowingText = this.hasGlowingText.witClone; + return clone; + } +} diff --git a/src/wit/pumpkin/plugin/block_entity/imports.d b/src/wit/pumpkin/plugin/block_entity/imports.d new file mode 100644 index 0000000..5ebef1a --- /dev/null +++ b/src/wit/pumpkin/plugin/block_entity/imports.d @@ -0,0 +1,5827 @@ +/++ + ++/ +module wit.pumpkin.plugin.block_entity.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.block_entity.common; + +static import wit.pumpkin.plugin.common.imports; +static import wit.pumpkin.plugin.item_stack.imports; +static import wit.pumpkin.plugin.inventory.imports; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias ItemStack = wit.pumpkin.plugin.item_stack.imports.ItemStack; + +/++ + ++/ +alias Inventory = wit.pumpkin.plugin.inventory.imports.Inventory; + +/++ + ++/ +struct BlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + WitString resourceLocation() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_resourceLocation(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]block-entity.resource-location") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:block_entity.resource_location") + static private extern(C) void __import_resourceLocation(uint, void*) nothrow; + + /++ + + +/ + BlockPos getPosition() @trusted nothrow { + align(4) void[12] _retArea = void; + __import_getPosition(this.__handle, _retArea.ptr); + wit.pumpkin.plugin.common.imports.BlockPos _record0 = { + x: cast(int)(*(cast(uint*)(_retArea.ptr + 0))), + y: cast(int)(*(cast(uint*)(_retArea.ptr + 4))), + z: cast(int)(*(cast(uint*)(_retArea.ptr + 8))), + }; + auto _flush1 = _record0; + return _flush1; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]block-entity.get-position") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:block_entity.get_position") + static private extern(C) void __import_getPosition(uint, void*) nothrow; + + /++ + + +/ + uint getId() @trusted nothrow { + auto _ret = __import_getId(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]block-entity.get-id") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:block_entity.get_id") + static private extern(C) uint __import_getId(uint) nothrow; + + /++ + + +/ + bool isDirty() @trusted nothrow { + auto _ret = __import_isDirty(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]block-entity.is-dirty") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:block_entity.is_dirty") + static private extern(C) uint __import_isDirty(uint) nothrow; + + /++ + + +/ + void clearDirty() @trusted nothrow { + __import_clearDirty(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]block-entity.clear-dirty") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:block_entity.clear_dirty") + static private extern(C) void __import_clearDirty(uint) nothrow; + + /++ + Sets a namespaced custom data value on this block entity. + +/ + void setCustomData(in WitString namespace, in WitString key, in NbtTree value) @trusted nothrow { + wit.common.DeallocateBuffer deallocate; + auto _listSrc28 = value.tags; + auto _list28 = _listSrc28.length ? wit.common.malloc(_listSrc28.length * ((8+2*size_t.sizeof))) : null; + assert(!_listSrc28.length || _list28); + if (_listSrc28.length) deallocate ~= _list28; + foreach (_elem0_idx, ref _elem0; _listSrc28) { + auto _base0 = _list28 + _elem0_idx * ((8+2*size_t.sizeof)); + alias _Tag27 = wit.pumpkin.plugin.common.imports.NbtTag.Tag; + final switch (_elem0.tag) { + case _Tag27.byte_: { + const ref byte _payload2 = _elem0.getByte(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(0); + *cast(ubyte*)(_base0 + 8) = cast(ubyte)(cast(uint)(_payload2)); + break; + } + case _Tag27.short_: { + const ref short _payload4 = _elem0.getShort(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(1); + *cast(ushort*)(_base0 + 8) = cast(ushort)(cast(uint)(_payload4)); + break; + } + case _Tag27.int_: { + const ref int _payload6 = _elem0.getInt(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(2); + *cast(uint*)(_base0 + 8) = cast(uint)(cast(uint)(_payload6)); + break; + } + case _Tag27.long_: { + const ref long _payload8 = _elem0.getLong(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(3); + *cast(ulong*)(_base0 + 8) = cast(ulong)(cast(ulong)(_payload8)); + break; + } + case _Tag27.float_: { + const ref float _payload10 = _elem0.getFloat(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(4); + *cast(float*)(_base0 + 8) = cast(float)(_payload10); + break; + } + case _Tag27.double_: { + const ref double _payload12 = _elem0.getDouble(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(5); + *cast(double*)(_base0 + 8) = cast(double)(_payload12); + break; + } + case _Tag27.byteArray: { + const ref WitList!(byte) _payload14 = _elem0.getByteArray(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(6); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload14.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload14.ptr)); + break; + } + case _Tag27.stringTag: { + const ref WitString _payload16 = _elem0.getStringTag(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(7); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload16.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload16.ptr)); + break; + } + case _Tag27.listTag: { + const ref WitList!(uint) _payload18 = _elem0.getListTag(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(8); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload18.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload18.ptr)); + break; + } + case _Tag27.compound: { + const ref WitList!(wit.pumpkin.plugin.common.imports.NbtEntry) _payload20 = _elem0.getCompound(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(9); + auto _listSrc22 = _payload20; + auto _list22 = _listSrc22.length ? wit.common.malloc(_listSrc22.length * ((3*size_t.sizeof))) : null; + assert(!_listSrc22.length || _list22); + if (_listSrc22.length) deallocate ~= _list22; + foreach (_elem21_idx, ref _elem21; _listSrc22) { + auto _base21 = _list22 + _elem21_idx * ((3*size_t.sizeof)); + *cast(size_t*)(_base21 + size_t.sizeof) = cast(size_t)(_elem21.key.length); + *cast(void**)(_base21 + 0) = cast(void*)(cast(void*)(_elem21.key.ptr)); + *cast(uint*)(_base21 + (2*size_t.sizeof)) = cast(uint)(_elem21.value); + + } + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload20.length); + *cast(void**)(_base0 + 8) = cast(void*)(_list22); + break; + } + case _Tag27.intArray: { + const ref WitList!(int) _payload24 = _elem0.getIntArray(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(10); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload24.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload24.ptr)); + break; + } + case _Tag27.longArray: { + const ref WitList!(long) _payload26 = _elem0.getLongArray(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(11); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload26.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload26.ptr)); + break; + } + } + + } + __import_setCustomData(this.__handle, cast(void*)(namespace.ptr), namespace.length, cast(void*)(key.ptr), key.length, value.root, _list28, value.tags.length); + deallocate.purge(); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]block-entity.set-custom-data") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:block_entity.set_custom_data") + static private extern(C) void __import_setCustomData(uint, void*, size_t, void*, size_t, uint, void*, size_t) nothrow; + + /++ + Returns a namespaced custom data value from this block entity, if set. + +/ + Option!(NbtTree) getCustomData(in WitString namespace, in WitString key) @trusted nothrow { + align(size_t.sizeof) void[(4*size_t.sizeof)] _retArea = void; + __import_getCustomData(this.__handle, cast(void*)(namespace.ptr), namespace.length, cast(void*)(key.ptr), key.length, _retArea.ptr); + Option!(NbtTree) _option47 = void; + bool _isSome47 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome47) { + auto _listSrcPtr44 = *(cast(void**)(_retArea.ptr + (2*size_t.sizeof))); + auto _listLen44 = *(cast(size_t*)(_retArea.ptr + (3*size_t.sizeof))); + auto _list44 = _listLen44 ? wit.common.mallocSlice!(wit.pumpkin.plugin.common.imports.NbtTag)(_listLen44) : []; + assert(!_listLen44 || _list44.ptr); + foreach (_elem2_idx, ref _elem2; _list44) { + const auto _base2 = _listSrcPtr44 + _elem2_idx * (8+2*size_t.sizeof); + wit.pumpkin.plugin.common.imports.NbtTag _variant31 = void; + auto _tag31 = cast(uint)(*(cast(ubyte*)(_base2 + 0))); + alias _Tag31 = wit.pumpkin.plugin.common.imports.NbtTag.Tag; + final switch (cast(wit.pumpkin.plugin.common.imports.NbtTag.Tag)_tag31) { + case _Tag31.byte_: { + auto _payload32 = cast(byte)(cast(uint)(*(cast(byte*)(_base2 + 8)))); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.byte_(_payload32); + break; + } + case _Tag31.short_: { + auto _payload33 = cast(short)(cast(uint)(*(cast(short*)(_base2 + 8)))); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.short_(_payload33); + break; + } + case _Tag31.int_: { + auto _payload34 = cast(int)(*(cast(uint*)(_base2 + 8))); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.int_(_payload34); + break; + } + case _Tag31.long_: { + auto _payload35 = cast(long)(*(cast(ulong*)(_base2 + 8))); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.long_(_payload35); + break; + } + case _Tag31.float_: { + auto _payload36 = *(cast(float*)(_base2 + 8)); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.float_(_payload36); + break; + } + case _Tag31.double_: { + auto _payload37 = *(cast(double*)(_base2 + 8)); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.double_(_payload37); + break; + } + case _Tag31.byteArray: { + auto _len10 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr10 = _len10 ? cast(byte*)(*(cast(void**)(_base2 + 8))) : null; + auto _list11 = WitList!(byte)(_ptr10[0.._len10]); + auto _payload38 = _list11; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.byteArray(_payload38); + break; + } + case _Tag31.stringTag: { + auto _len13 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr13 = _len13 ? cast(char*)(*(cast(void**)(_base2 + 8))) : null; + auto _list14 = WitString(_ptr13[0.._len13]); + auto _payload39 = _list14; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.stringTag(_payload39); + break; + } + case _Tag31.listTag: { + auto _len16 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr16 = _len16 ? cast(uint*)(*(cast(void**)(_base2 + 8))) : null; + auto _list17 = WitList!(uint)(_ptr16[0.._len16]); + auto _payload40 = _list17; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.listTag(_payload40); + break; + } + case _Tag31.compound: { + auto _listSrcPtr23 = *(cast(void**)(_base2 + 8)); + auto _listLen23 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _list23 = _listLen23 ? wit.common.mallocSlice!(wit.pumpkin.plugin.common.imports.NbtEntry)(_listLen23) : []; + assert(!_listLen23 || _list23.ptr); + foreach (_elem19_idx, ref _elem19; _list23) { + const auto _base19 = _listSrcPtr23 + _elem19_idx * (3*size_t.sizeof); + auto _len20 = *(cast(size_t*)(_base19 + size_t.sizeof)); + auto _ptr20 = _len20 ? cast(char*)(*(cast(void**)(_base19 + 0))) : null; + auto _list21 = WitString(_ptr20[0.._len20]); + wit.pumpkin.plugin.common.imports.NbtEntry _record22 = { + key: _list21, + value: *(cast(uint*)(_base19 + (2*size_t.sizeof))), + }; + _elem19 = _record22; + } + if (_listLen23) wit.common.free(_listSrcPtr23); + auto _witList24 = WitList!(wit.pumpkin.plugin.common.imports.NbtEntry)(_list23); + auto _payload41 = _witList24; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.compound(_payload41); + break; + } + case _Tag31.intArray: { + auto _len26 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr26 = _len26 ? cast(int*)(*(cast(void**)(_base2 + 8))) : null; + auto _list27 = WitList!(int)(_ptr26[0.._len26]); + auto _payload42 = _list27; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.intArray(_payload42); + break; + } + case _Tag31.longArray: { + auto _len29 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr29 = _len29 ? cast(long*)(*(cast(void**)(_base2 + 8))) : null; + auto _list30 = WitList!(long)(_ptr29[0.._len29]); + auto _payload43 = _list30; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.longArray(_payload43); + break; + } + } + _elem2 = _variant31; + } + if (_listLen44) wit.common.free(_listSrcPtr44); + auto _witList45 = WitList!(wit.pumpkin.plugin.common.imports.NbtTag)(_list44); + wit.pumpkin.plugin.common.imports.NbtTree _record46 = { + root: *(cast(uint*)(_retArea.ptr + size_t.sizeof)), + tags: _witList45, + }; + + _option47 = Option!(NbtTree).makeSome(_record46); + } else { + _option47 = Option!(NbtTree).makeNone; + } + auto _flush48 = _option47; + return _flush48; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]block-entity.get-custom-data") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:block_entity.get_custom_data") + static private extern(C) void __import_getCustomData(uint, void*, size_t, void*, size_t, void*) nothrow; + + /++ + Removes a namespaced custom data value from this block entity. + +/ + void removeCustomData(in WitString namespace, in WitString key) @trusted nothrow { + __import_removeCustomData(this.__handle, cast(void*)(namespace.ptr), namespace.length, cast(void*)(key.ptr), key.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]block-entity.remove-custom-data") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:block_entity.remove_custom_data") + static private extern(C) void __import_removeCustomData(uint, void*, size_t, void*, size_t) nothrow; + + /++ + Returns whether this block entity has a namespaced custom data value. + +/ + bool hasCustomData(in WitString namespace, in WitString key) @trusted nothrow { + auto _ret = __import_hasCustomData(this.__handle, cast(void*)(namespace.ptr), namespace.length, cast(void*)(key.ptr), key.length); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]block-entity.has-custom-data") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:block_entity.has_custom_data") + static private extern(C) uint __import_hasCustomData(uint, void*, size_t, void*, size_t) nothrow; + } +} + +/++ + ++/ +struct ContainerBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]container-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:container_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]container-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:container_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + Returns the generic inventory handle for this container. + +/ + Inventory getInventory() @trusted nothrow { + auto _ret = __import_getInventory(this.__handle); + auto _handle0 = Inventory(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]container-block-entity.get-inventory") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:container_block_entity.get_inventory") + static private extern(C) uint __import_getInventory(uint) nothrow; + + /++ + + +/ + uint getSize() @trusted nothrow { + auto _ret = __import_getSize(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]container-block-entity.get-size") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:container_block_entity.get_size") + static private extern(C) uint __import_getSize(uint) nothrow; + + /++ + + +/ + bool isEmpty() @trusted nothrow { + auto _ret = __import_isEmpty(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]container-block-entity.is-empty") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:container_block_entity.is_empty") + static private extern(C) uint __import_isEmpty(uint) nothrow; + + /++ + + +/ + Option!(ItemStack) getStack(uint slot) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getStack(this.__handle, slot, _retArea.ptr); + Option!(ItemStack) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = ItemStack(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(ItemStack).makeSome(_handle2); + } else { + _option3 = Option!(ItemStack).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]container-block-entity.get-stack") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:container_block_entity.get_stack") + static private extern(C) void __import_getStack(uint, uint, void*) nothrow; + + /++ + + +/ + void setStack(uint slot, in Option!(ItemStack) stack) @trusted nothrow { + uint _option4 = void; + uint _option5 = void; + if (stack.isSome) { + ref _payload3 = stack.unwrap(); + _option4 = 1; + _option5 = _payload3.__handle; + } else { + _option4 = 0; + _option5 = 0; + } + __import_setStack(this.__handle, slot, _option4, _option5); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]container-block-entity.set-stack") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:container_block_entity.set_stack") + static private extern(C) void __import_setStack(uint, uint, uint, uint) nothrow; + + /++ + + +/ + Option!(ItemStack) removeStack(uint slot) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_removeStack(this.__handle, slot, _retArea.ptr); + Option!(ItemStack) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = ItemStack(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(ItemStack).makeSome(_handle2); + } else { + _option3 = Option!(ItemStack).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]container-block-entity.remove-stack") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:container_block_entity.remove_stack") + static private extern(C) void __import_removeStack(uint, uint, void*) nothrow; + + /++ + + +/ + void clear() @trusted nothrow { + __import_clear(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]container-block-entity.clear") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:container_block_entity.clear") + static private extern(C) void __import_clear(uint) nothrow; + } +} + +/++ + ++/ +struct CommandBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]command-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:command_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]command-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:command_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + WitString lastOutput() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_lastOutput(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]command-block-entity.last-output") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:command_block_entity.last_output") + static private extern(C) void __import_lastOutput(uint, void*) nothrow; + + /++ + + +/ + bool trackOutput() @trusted nothrow { + auto _ret = __import_trackOutput(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]command-block-entity.track-output") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:command_block_entity.track_output") + static private extern(C) uint __import_trackOutput(uint) nothrow; + + /++ + + +/ + uint successCount() @trusted nothrow { + auto _ret = __import_successCount(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]command-block-entity.success-count") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:command_block_entity.success_count") + static private extern(C) uint __import_successCount(uint) nothrow; + + /++ + + +/ + WitString command() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_command(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]command-block-entity.command") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:command_block_entity.command") + static private extern(C) void __import_command(uint, void*) nothrow; + + /++ + + +/ + bool auto_() @trusted nothrow { + auto _ret = __import_auto_(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]command-block-entity.auto") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:command_block_entity.auto") + static private extern(C) uint __import_auto_(uint) nothrow; + + /++ + + +/ + bool conditionMet() @trusted nothrow { + auto _ret = __import_conditionMet(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]command-block-entity.condition-met") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:command_block_entity.condition_met") + static private extern(C) uint __import_conditionMet(uint) nothrow; + + /++ + + +/ + bool powered() @trusted nothrow { + auto _ret = __import_powered(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]command-block-entity.powered") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:command_block_entity.powered") + static private extern(C) uint __import_powered(uint) nothrow; + } +} + +/++ + ++/ +struct SignBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]sign-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:sign_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]sign-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:sign_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + SignText getFrontText() @trusted nothrow { + align(size_t.sizeof) void[(3*size_t.sizeof)] _retArea = void; + __import_getFrontText(this.__handle, _retArea.ptr); + auto _listSrcPtr3 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen3 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list3 = _listLen3 ? wit.common.mallocSlice!(WitString)(_listLen3) : []; + assert(!_listLen3 || _list3.ptr); + foreach (_elem0_idx, ref _elem0; _list3) { + const auto _base0 = _listSrcPtr3 + _elem0_idx * (2*size_t.sizeof); + auto _len1 = *(cast(size_t*)(_base0 + size_t.sizeof)); + auto _ptr1 = _len1 ? cast(char*)(*(cast(void**)(_base0 + 0))) : null; + auto _list2 = WitString(_ptr1[0.._len1]); + _elem0 = _list2; + } + if (_listLen3) wit.common.free(_listSrcPtr3); + auto _witList4 = WitList!(WitString)(_list3); + SignText _record5 = { + messages: _witList4, + color: cast(DyeColor)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (2*size_t.sizeof))))), + hasGlowingText: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (1+2*size_t.sizeof))))) != 0, + }; + auto _flush6 = _record5; + return _flush6; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]sign-block-entity.get-front-text") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:sign_block_entity.get_front_text") + static private extern(C) void __import_getFrontText(uint, void*) nothrow; + + /++ + + +/ + void setFrontText(in SignText text) @trusted nothrow { + wit.common.DeallocateBuffer deallocate; + auto _listSrc1 = text.messages; + auto _list1 = _listSrc1.length ? wit.common.malloc(_listSrc1.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc1.length || _list1); + if (_listSrc1.length) deallocate ~= _list1; + foreach (_elem0_idx, ref _elem0; _listSrc1) { + auto _base0 = _list1 + _elem0_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base0 + size_t.sizeof) = cast(size_t)(_elem0.length); + *cast(void**)(_base0 + 0) = cast(void*)(cast(void*)(_elem0.ptr)); + + } + __import_setFrontText(this.__handle, _list1, text.messages.length, cast(uint)(text.color), cast(uint)(text.hasGlowingText)); + deallocate.purge(); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]sign-block-entity.set-front-text") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:sign_block_entity.set_front_text") + static private extern(C) void __import_setFrontText(uint, void*, size_t, uint, uint) nothrow; + + /++ + + +/ + SignText getBackText() @trusted nothrow { + align(size_t.sizeof) void[(3*size_t.sizeof)] _retArea = void; + __import_getBackText(this.__handle, _retArea.ptr); + auto _listSrcPtr3 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen3 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list3 = _listLen3 ? wit.common.mallocSlice!(WitString)(_listLen3) : []; + assert(!_listLen3 || _list3.ptr); + foreach (_elem0_idx, ref _elem0; _list3) { + const auto _base0 = _listSrcPtr3 + _elem0_idx * (2*size_t.sizeof); + auto _len1 = *(cast(size_t*)(_base0 + size_t.sizeof)); + auto _ptr1 = _len1 ? cast(char*)(*(cast(void**)(_base0 + 0))) : null; + auto _list2 = WitString(_ptr1[0.._len1]); + _elem0 = _list2; + } + if (_listLen3) wit.common.free(_listSrcPtr3); + auto _witList4 = WitList!(WitString)(_list3); + SignText _record5 = { + messages: _witList4, + color: cast(DyeColor)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (2*size_t.sizeof))))), + hasGlowingText: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (1+2*size_t.sizeof))))) != 0, + }; + auto _flush6 = _record5; + return _flush6; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]sign-block-entity.get-back-text") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:sign_block_entity.get_back_text") + static private extern(C) void __import_getBackText(uint, void*) nothrow; + + /++ + + +/ + void setBackText(in SignText text) @trusted nothrow { + wit.common.DeallocateBuffer deallocate; + auto _listSrc1 = text.messages; + auto _list1 = _listSrc1.length ? wit.common.malloc(_listSrc1.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc1.length || _list1); + if (_listSrc1.length) deallocate ~= _list1; + foreach (_elem0_idx, ref _elem0; _listSrc1) { + auto _base0 = _list1 + _elem0_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base0 + size_t.sizeof) = cast(size_t)(_elem0.length); + *cast(void**)(_base0 + 0) = cast(void*)(cast(void*)(_elem0.ptr)); + + } + __import_setBackText(this.__handle, _list1, text.messages.length, cast(uint)(text.color), cast(uint)(text.hasGlowingText)); + deallocate.purge(); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]sign-block-entity.set-back-text") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:sign_block_entity.set_back_text") + static private extern(C) void __import_setBackText(uint, void*, size_t, uint, uint) nothrow; + + /++ + + +/ + bool isWaxed() @trusted nothrow { + auto _ret = __import_isWaxed(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]sign-block-entity.is-waxed") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:sign_block_entity.is_waxed") + static private extern(C) uint __import_isWaxed(uint) nothrow; + + /++ + + +/ + void setWaxed(bool waxed) @trusted nothrow { + __import_setWaxed(this.__handle, cast(uint)(waxed)); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]sign-block-entity.set-waxed") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:sign_block_entity.set_waxed") + static private extern(C) void __import_setWaxed(uint, uint) nothrow; + } +} + +/++ + ++/ +struct JukeboxBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]jukebox-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:jukebox_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]jukebox-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:jukebox_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + ContainerBlockEntity getContainer() @trusted nothrow { + auto _ret = __import_getContainer(this.__handle); + auto _handle0 = ContainerBlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]jukebox-block-entity.get-container") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:jukebox_block_entity.get_container") + static private extern(C) uint __import_getContainer(uint) nothrow; + + /++ + + +/ + bool isPlaying() @trusted nothrow { + auto _ret = __import_isPlaying(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]jukebox-block-entity.is-playing") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:jukebox_block_entity.is_playing") + static private extern(C) uint __import_isPlaying(uint) nothrow; + + /++ + + +/ + void stopPlaying() @trusted nothrow { + __import_stopPlaying(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]jukebox-block-entity.stop-playing") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:jukebox_block_entity.stop_playing") + static private extern(C) void __import_stopPlaying(uint) nothrow; + + /++ + + +/ + void startPlaying(ulong lengthInTicks) @trusted nothrow { + __import_startPlaying(this.__handle, lengthInTicks); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]jukebox-block-entity.start-playing") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:jukebox_block_entity.start_playing") + static private extern(C) void __import_startPlaying(uint, ulong) nothrow; + } +} + +/++ + ++/ +struct ChestBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]chest-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:chest_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]chest-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:chest_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + ContainerBlockEntity getContainer() @trusted nothrow { + auto _ret = __import_getContainer(this.__handle); + auto _handle0 = ContainerBlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]chest-block-entity.get-container") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:chest_block_entity.get_container") + static private extern(C) uint __import_getContainer(uint) nothrow; + + /++ + + +/ + uint viewerCount() @trusted nothrow { + auto _ret = __import_viewerCount(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]chest-block-entity.viewer-count") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:chest_block_entity.viewer_count") + static private extern(C) uint __import_viewerCount(uint) nothrow; + } +} + +/++ + ++/ +struct MobSpawnerBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]mob-spawner-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:mob_spawner_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]mob-spawner-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:mob_spawner_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + int getSpawnCount() @trusted nothrow { + auto _ret = __import_getSpawnCount(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]mob-spawner-block-entity.get-spawn-count") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:mob_spawner_block_entity.get_spawn_count") + static private extern(C) uint __import_getSpawnCount(uint) nothrow; + + /++ + + +/ + int getSpawnRange() @trusted nothrow { + auto _ret = __import_getSpawnRange(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]mob-spawner-block-entity.get-spawn-range") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:mob_spawner_block_entity.get_spawn_range") + static private extern(C) uint __import_getSpawnRange(uint) nothrow; + + /++ + + +/ + int getDelay() @trusted nothrow { + auto _ret = __import_getDelay(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]mob-spawner-block-entity.get-delay") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:mob_spawner_block_entity.get_delay") + static private extern(C) uint __import_getDelay(uint) nothrow; + } +} + +/++ + ++/ +struct MapBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]map-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:map_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]map-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:map_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + int getMapId() @trusted nothrow { + auto _ret = __import_getMapId(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]map-block-entity.get-map-id") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:map_block_entity.get_map_id") + static private extern(C) uint __import_getMapId(uint) nothrow; + + /++ + + +/ + void setMapId(int mapId) @trusted nothrow { + __import_setMapId(this.__handle, cast(uint)(mapId)); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]map-block-entity.set-map-id") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:map_block_entity.set_map_id") + static private extern(C) void __import_setMapId(uint, uint) nothrow; + + /++ + + +/ + WitList!(ubyte) getColors() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getColors(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(ubyte*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitList!(ubyte)(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]map-block-entity.get-colors") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:map_block_entity.get_colors") + static private extern(C) void __import_getColors(uint, void*) nothrow; + + /++ + + +/ + void setColors(in WitList!(ubyte) colors) @trusted nothrow { + __import_setColors(this.__handle, cast(void*)(colors.ptr), colors.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]map-block-entity.set-colors") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:map_block_entity.set_colors") + static private extern(C) void __import_setColors(uint, void*, size_t) nothrow; + + /++ + + +/ + void setPixel(uint x, uint y, ubyte color) @trusted nothrow { + __import_setPixel(this.__handle, x, y, cast(uint)(color)); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]map-block-entity.set-pixel") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:map_block_entity.set_pixel") + static private extern(C) void __import_setPixel(uint, uint, uint, uint) nothrow; + + /++ + + +/ + ubyte getPixel(uint x, uint y) @trusted nothrow { + auto _ret = __import_getPixel(this.__handle, x, y); + return cast(ubyte)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]map-block-entity.get-pixel") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:map_block_entity.get_pixel") + static private extern(C) uint __import_getPixel(uint, uint, uint) nothrow; + + /++ + + +/ + void update() @trusted nothrow { + __import_update(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]map-block-entity.update") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:map_block_entity.update") + static private extern(C) void __import_update(uint) nothrow; + + /++ + + +/ + void streamFrame(in WitList!(ubyte) frameData) @trusted nothrow { + __import_streamFrame(this.__handle, cast(void*)(frameData.ptr), frameData.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]map-block-entity.stream-frame") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:map_block_entity.stream_frame") + static private extern(C) void __import_streamFrame(uint, void*, size_t) nothrow; + } +} + +/++ + ++/ +struct HangingSignBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]hanging-sign-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:hanging_sign_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]hanging-sign-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:hanging_sign_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + SignText getFrontText() @trusted nothrow { + align(size_t.sizeof) void[(3*size_t.sizeof)] _retArea = void; + __import_getFrontText(this.__handle, _retArea.ptr); + auto _listSrcPtr3 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen3 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list3 = _listLen3 ? wit.common.mallocSlice!(WitString)(_listLen3) : []; + assert(!_listLen3 || _list3.ptr); + foreach (_elem0_idx, ref _elem0; _list3) { + const auto _base0 = _listSrcPtr3 + _elem0_idx * (2*size_t.sizeof); + auto _len1 = *(cast(size_t*)(_base0 + size_t.sizeof)); + auto _ptr1 = _len1 ? cast(char*)(*(cast(void**)(_base0 + 0))) : null; + auto _list2 = WitString(_ptr1[0.._len1]); + _elem0 = _list2; + } + if (_listLen3) wit.common.free(_listSrcPtr3); + auto _witList4 = WitList!(WitString)(_list3); + SignText _record5 = { + messages: _witList4, + color: cast(DyeColor)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (2*size_t.sizeof))))), + hasGlowingText: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (1+2*size_t.sizeof))))) != 0, + }; + auto _flush6 = _record5; + return _flush6; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]hanging-sign-block-entity.get-front-text") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:hanging_sign_block_entity.get_front_text") + static private extern(C) void __import_getFrontText(uint, void*) nothrow; + + /++ + + +/ + void setFrontText(in SignText text) @trusted nothrow { + wit.common.DeallocateBuffer deallocate; + auto _listSrc1 = text.messages; + auto _list1 = _listSrc1.length ? wit.common.malloc(_listSrc1.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc1.length || _list1); + if (_listSrc1.length) deallocate ~= _list1; + foreach (_elem0_idx, ref _elem0; _listSrc1) { + auto _base0 = _list1 + _elem0_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base0 + size_t.sizeof) = cast(size_t)(_elem0.length); + *cast(void**)(_base0 + 0) = cast(void*)(cast(void*)(_elem0.ptr)); + + } + __import_setFrontText(this.__handle, _list1, text.messages.length, cast(uint)(text.color), cast(uint)(text.hasGlowingText)); + deallocate.purge(); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]hanging-sign-block-entity.set-front-text") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:hanging_sign_block_entity.set_front_text") + static private extern(C) void __import_setFrontText(uint, void*, size_t, uint, uint) nothrow; + + /++ + + +/ + SignText getBackText() @trusted nothrow { + align(size_t.sizeof) void[(3*size_t.sizeof)] _retArea = void; + __import_getBackText(this.__handle, _retArea.ptr); + auto _listSrcPtr3 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen3 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list3 = _listLen3 ? wit.common.mallocSlice!(WitString)(_listLen3) : []; + assert(!_listLen3 || _list3.ptr); + foreach (_elem0_idx, ref _elem0; _list3) { + const auto _base0 = _listSrcPtr3 + _elem0_idx * (2*size_t.sizeof); + auto _len1 = *(cast(size_t*)(_base0 + size_t.sizeof)); + auto _ptr1 = _len1 ? cast(char*)(*(cast(void**)(_base0 + 0))) : null; + auto _list2 = WitString(_ptr1[0.._len1]); + _elem0 = _list2; + } + if (_listLen3) wit.common.free(_listSrcPtr3); + auto _witList4 = WitList!(WitString)(_list3); + SignText _record5 = { + messages: _witList4, + color: cast(DyeColor)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (2*size_t.sizeof))))), + hasGlowingText: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (1+2*size_t.sizeof))))) != 0, + }; + auto _flush6 = _record5; + return _flush6; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]hanging-sign-block-entity.get-back-text") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:hanging_sign_block_entity.get_back_text") + static private extern(C) void __import_getBackText(uint, void*) nothrow; + + /++ + + +/ + void setBackText(in SignText text) @trusted nothrow { + wit.common.DeallocateBuffer deallocate; + auto _listSrc1 = text.messages; + auto _list1 = _listSrc1.length ? wit.common.malloc(_listSrc1.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc1.length || _list1); + if (_listSrc1.length) deallocate ~= _list1; + foreach (_elem0_idx, ref _elem0; _listSrc1) { + auto _base0 = _list1 + _elem0_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base0 + size_t.sizeof) = cast(size_t)(_elem0.length); + *cast(void**)(_base0 + 0) = cast(void*)(cast(void*)(_elem0.ptr)); + + } + __import_setBackText(this.__handle, _list1, text.messages.length, cast(uint)(text.color), cast(uint)(text.hasGlowingText)); + deallocate.purge(); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]hanging-sign-block-entity.set-back-text") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:hanging_sign_block_entity.set_back_text") + static private extern(C) void __import_setBackText(uint, void*, size_t, uint, uint) nothrow; + + /++ + + +/ + bool isWaxed() @trusted nothrow { + auto _ret = __import_isWaxed(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]hanging-sign-block-entity.is-waxed") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:hanging_sign_block_entity.is_waxed") + static private extern(C) uint __import_isWaxed(uint) nothrow; + + /++ + + +/ + void setWaxed(bool waxed) @trusted nothrow { + __import_setWaxed(this.__handle, cast(uint)(waxed)); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]hanging-sign-block-entity.set-waxed") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:hanging_sign_block_entity.set_waxed") + static private extern(C) void __import_setWaxed(uint, uint) nothrow; + } +} + +/++ + ++/ +struct TrappedChestBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]trapped-chest-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:trapped_chest_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]trapped-chest-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:trapped_chest_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + ContainerBlockEntity getContainer() @trusted nothrow { + auto _ret = __import_getContainer(this.__handle); + auto _handle0 = ContainerBlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]trapped-chest-block-entity.get-container") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:trapped_chest_block_entity.get_container") + static private extern(C) uint __import_getContainer(uint) nothrow; + + /++ + + +/ + uint viewerCount() @trusted nothrow { + auto _ret = __import_viewerCount(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]trapped-chest-block-entity.viewer-count") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:trapped_chest_block_entity.viewer_count") + static private extern(C) uint __import_viewerCount(uint) nothrow; + } +} + +/++ + ++/ +struct BannerBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]banner-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:banner_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]banner-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:banner_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + Option!(WitString) getCustomName() @trusted nothrow { + align(size_t.sizeof) void[(3*size_t.sizeof)] _retArea = void; + __import_getCustomName(this.__handle, _retArea.ptr); + Option!(WitString) _option4 = void; + bool _isSome4 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome4) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + + _option4 = Option!(WitString).makeSome(_list3); + } else { + _option4 = Option!(WitString).makeNone; + } + auto _flush5 = _option4; + return _flush5; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]banner-block-entity.get-custom-name") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:banner_block_entity.get_custom_name") + static private extern(C) void __import_getCustomName(uint, void*) nothrow; + } +} + +/++ + ++/ +struct BarrelBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]barrel-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:barrel_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]barrel-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:barrel_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + ContainerBlockEntity getContainer() @trusted nothrow { + auto _ret = __import_getContainer(this.__handle); + auto _handle0 = ContainerBlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]barrel-block-entity.get-container") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:barrel_block_entity.get_container") + static private extern(C) uint __import_getContainer(uint) nothrow; + + /++ + + +/ + uint viewerCount() @trusted nothrow { + auto _ret = __import_viewerCount(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]barrel-block-entity.viewer-count") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:barrel_block_entity.viewer_count") + static private extern(C) uint __import_viewerCount(uint) nothrow; + } +} + +/++ + ++/ +struct BeaconBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]beacon-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:beacon_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]beacon-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:beacon_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + ContainerBlockEntity getContainer() @trusted nothrow { + auto _ret = __import_getContainer(this.__handle); + auto _handle0 = ContainerBlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]beacon-block-entity.get-container") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:beacon_block_entity.get_container") + static private extern(C) uint __import_getContainer(uint) nothrow; + + /++ + + +/ + int getPrimaryEffect() @trusted nothrow { + auto _ret = __import_getPrimaryEffect(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]beacon-block-entity.get-primary-effect") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:beacon_block_entity.get_primary_effect") + static private extern(C) uint __import_getPrimaryEffect(uint) nothrow; + + /++ + + +/ + int getSecondaryEffect() @trusted nothrow { + auto _ret = __import_getSecondaryEffect(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]beacon-block-entity.get-secondary-effect") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:beacon_block_entity.get_secondary_effect") + static private extern(C) uint __import_getSecondaryEffect(uint) nothrow; + + /++ + + +/ + int getLevels() @trusted nothrow { + auto _ret = __import_getLevels(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]beacon-block-entity.get-levels") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:beacon_block_entity.get_levels") + static private extern(C) uint __import_getLevels(uint) nothrow; + } +} + +/++ + ++/ +struct BedBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]bed-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:bed_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]bed-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:bed_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + } +} + +/++ + ++/ +struct BeehiveBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]beehive-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:beehive_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]beehive-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:beehive_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + uint getBeeCount() @trusted nothrow { + auto _ret = __import_getBeeCount(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]beehive-block-entity.get-bee-count") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:beehive_block_entity.get_bee_count") + static private extern(C) uint __import_getBeeCount(uint) nothrow; + } +} + +/++ + ++/ +struct BellBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]bell-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:bell_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]bell-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:bell_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + bool isRinging() @trusted nothrow { + auto _ret = __import_isRinging(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]bell-block-entity.is-ringing") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:bell_block_entity.is_ringing") + static private extern(C) uint __import_isRinging(uint) nothrow; + + /++ + + +/ + int getRingTicks() @trusted nothrow { + auto _ret = __import_getRingTicks(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]bell-block-entity.get-ring-ticks") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:bell_block_entity.get_ring_ticks") + static private extern(C) uint __import_getRingTicks(uint) nothrow; + } +} + +/++ + ++/ +struct BlastingFurnaceBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]blasting-furnace-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:blasting_furnace_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]blasting-furnace-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:blasting_furnace_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + ContainerBlockEntity getContainer() @trusted nothrow { + auto _ret = __import_getContainer(this.__handle); + auto _handle0 = ContainerBlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]blasting-furnace-block-entity.get-container") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:blasting_furnace_block_entity.get_container") + static private extern(C) uint __import_getContainer(uint) nothrow; + + /++ + + +/ + ushort getCookingTimeSpent() @trusted nothrow { + auto _ret = __import_getCookingTimeSpent(this.__handle); + return cast(ushort)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]blasting-furnace-block-entity.get-cooking-time-spent") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:blasting_furnace_block_entity.get_cooking_time_spent") + static private extern(C) uint __import_getCookingTimeSpent(uint) nothrow; + + /++ + + +/ + ushort getCookingTotalTime() @trusted nothrow { + auto _ret = __import_getCookingTotalTime(this.__handle); + return cast(ushort)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]blasting-furnace-block-entity.get-cooking-total-time") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:blasting_furnace_block_entity.get_cooking_total_time") + static private extern(C) uint __import_getCookingTotalTime(uint) nothrow; + + /++ + + +/ + ushort getLitTimeRemaining() @trusted nothrow { + auto _ret = __import_getLitTimeRemaining(this.__handle); + return cast(ushort)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]blasting-furnace-block-entity.get-lit-time-remaining") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:blasting_furnace_block_entity.get_lit_time_remaining") + static private extern(C) uint __import_getLitTimeRemaining(uint) nothrow; + + /++ + + +/ + ushort getLitTotalTime() @trusted nothrow { + auto _ret = __import_getLitTotalTime(this.__handle); + return cast(ushort)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]blasting-furnace-block-entity.get-lit-total-time") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:blasting_furnace_block_entity.get_lit_total_time") + static private extern(C) uint __import_getLitTotalTime(uint) nothrow; + + /++ + + +/ + bool isBurning() @trusted nothrow { + auto _ret = __import_isBurning(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]blasting-furnace-block-entity.is-burning") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:blasting_furnace_block_entity.is_burning") + static private extern(C) uint __import_isBurning(uint) nothrow; + } +} + +/++ + ++/ +struct BrewingStandBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]brewing-stand-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:brewing_stand_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]brewing-stand-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:brewing_stand_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + ContainerBlockEntity getContainer() @trusted nothrow { + auto _ret = __import_getContainer(this.__handle); + auto _handle0 = ContainerBlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]brewing-stand-block-entity.get-container") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:brewing_stand_block_entity.get_container") + static private extern(C) uint __import_getContainer(uint) nothrow; + + /++ + + +/ + int getBrewTime() @trusted nothrow { + auto _ret = __import_getBrewTime(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]brewing-stand-block-entity.get-brew-time") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:brewing_stand_block_entity.get_brew_time") + static private extern(C) uint __import_getBrewTime(uint) nothrow; + + /++ + + +/ + int getFuel() @trusted nothrow { + auto _ret = __import_getFuel(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]brewing-stand-block-entity.get-fuel") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:brewing_stand_block_entity.get_fuel") + static private extern(C) uint __import_getFuel(uint) nothrow; + } +} + +/++ + ++/ +struct BrushableBlockBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]brushable-block-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:brushable_block_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]brushable-block-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:brushable_block_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + } +} + +/++ + ++/ +struct CalibratedSculkSensorBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]calibrated-sculk-sensor-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:calibrated_sculk_sensor_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]calibrated-sculk-sensor-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:calibrated_sculk_sensor_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + } +} + +/++ + ++/ +struct CampfireBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]campfire-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:campfire_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]campfire-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:campfire_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + ContainerBlockEntity getContainer() @trusted nothrow { + auto _ret = __import_getContainer(this.__handle); + auto _handle0 = ContainerBlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]campfire-block-entity.get-container") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:campfire_block_entity.get_container") + static private extern(C) uint __import_getContainer(uint) nothrow; + } +} + +/++ + ++/ +struct ChiseledBookshelfBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]chiseled-bookshelf-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:chiseled_bookshelf_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]chiseled-bookshelf-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:chiseled_bookshelf_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + ContainerBlockEntity getContainer() @trusted nothrow { + auto _ret = __import_getContainer(this.__handle); + auto _handle0 = ContainerBlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]chiseled-bookshelf-block-entity.get-container") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:chiseled_bookshelf_block_entity.get_container") + static private extern(C) uint __import_getContainer(uint) nothrow; + + /++ + + +/ + byte getLastInteractedSlot() @trusted nothrow { + auto _ret = __import_getLastInteractedSlot(this.__handle); + return cast(byte)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]chiseled-bookshelf-block-entity.get-last-interacted-slot") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:chiseled_bookshelf_block_entity.get_last_interacted_slot") + static private extern(C) uint __import_getLastInteractedSlot(uint) nothrow; + } +} + +/++ + ++/ +struct ComparatorBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]comparator-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:comparator_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]comparator-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:comparator_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + ubyte getOutputSignal() @trusted nothrow { + auto _ret = __import_getOutputSignal(this.__handle); + return cast(ubyte)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]comparator-block-entity.get-output-signal") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:comparator_block_entity.get_output_signal") + static private extern(C) uint __import_getOutputSignal(uint) nothrow; + } +} + +/++ + ++/ +struct ConduitBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]conduit-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:conduit_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]conduit-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:conduit_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + } +} + +/++ + ++/ +struct CopperGolemStatueBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]copper-golem-statue-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:copper_golem_statue_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]copper-golem-statue-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:copper_golem_statue_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + } +} + +/++ + ++/ +struct CrafterBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]crafter-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:crafter_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]crafter-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:crafter_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + ContainerBlockEntity getContainer() @trusted nothrow { + auto _ret = __import_getContainer(this.__handle); + auto _handle0 = ContainerBlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]crafter-block-entity.get-container") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:crafter_block_entity.get_container") + static private extern(C) uint __import_getContainer(uint) nothrow; + + /++ + + +/ + int getCraftingTicksRemaining() @trusted nothrow { + auto _ret = __import_getCraftingTicksRemaining(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]crafter-block-entity.get-crafting-ticks-remaining") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:crafter_block_entity.get_crafting_ticks_remaining") + static private extern(C) uint __import_getCraftingTicksRemaining(uint) nothrow; + + /++ + + +/ + bool isTriggered() @trusted nothrow { + auto _ret = __import_isTriggered(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]crafter-block-entity.is-triggered") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:crafter_block_entity.is_triggered") + static private extern(C) uint __import_isTriggered(uint) nothrow; + } +} + +/++ + ++/ +struct CreakingHeartBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]creaking-heart-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:creaking_heart_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]creaking-heart-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:creaking_heart_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + Option!(WitString) getCreakingUuid() @trusted nothrow { + align(size_t.sizeof) void[(3*size_t.sizeof)] _retArea = void; + __import_getCreakingUuid(this.__handle, _retArea.ptr); + Option!(WitString) _option4 = void; + bool _isSome4 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome4) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + + _option4 = Option!(WitString).makeSome(_list3); + } else { + _option4 = Option!(WitString).makeNone; + } + auto _flush5 = _option4; + return _flush5; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]creaking-heart-block-entity.get-creaking-uuid") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:creaking_heart_block_entity.get_creaking_uuid") + static private extern(C) void __import_getCreakingUuid(uint, void*) nothrow; + } +} + +/++ + ++/ +struct DaylightDetectorBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]daylight-detector-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:daylight_detector_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]daylight-detector-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:daylight_detector_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + } +} + +/++ + ++/ +struct DecoratedPotBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]decorated-pot-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:decorated_pot_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]decorated-pot-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:decorated_pot_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + } +} + +/++ + ++/ +struct DispenserBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]dispenser-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:dispenser_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]dispenser-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:dispenser_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + ContainerBlockEntity getContainer() @trusted nothrow { + auto _ret = __import_getContainer(this.__handle); + auto _handle0 = ContainerBlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]dispenser-block-entity.get-container") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:dispenser_block_entity.get_container") + static private extern(C) uint __import_getContainer(uint) nothrow; + } +} + +/++ + ++/ +struct DropperBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]dropper-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:dropper_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]dropper-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:dropper_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + ContainerBlockEntity getContainer() @trusted nothrow { + auto _ret = __import_getContainer(this.__handle); + auto _handle0 = ContainerBlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]dropper-block-entity.get-container") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:dropper_block_entity.get_container") + static private extern(C) uint __import_getContainer(uint) nothrow; + } +} + +/++ + ++/ +struct EnchantingTableBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]enchanting-table-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:enchanting_table_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]enchanting-table-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:enchanting_table_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + } +} + +/++ + ++/ +struct EndGatewayBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]end-gateway-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:end_gateway_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]end-gateway-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:end_gateway_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + long getAge() @trusted nothrow { + auto _ret = __import_getAge(this.__handle); + return cast(long)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]end-gateway-block-entity.get-age") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:end_gateway_block_entity.get_age") + static private extern(C) ulong __import_getAge(uint) nothrow; + + /++ + + +/ + bool isExactTeleport() @trusted nothrow { + auto _ret = __import_isExactTeleport(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]end-gateway-block-entity.is-exact-teleport") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:end_gateway_block_entity.is_exact_teleport") + static private extern(C) uint __import_isExactTeleport(uint) nothrow; + } +} + +/++ + ++/ +struct EndPortalBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]end-portal-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:end_portal_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]end-portal-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:end_portal_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + } +} + +/++ + ++/ +struct EnderChestBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]ender-chest-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:ender_chest_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]ender-chest-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:ender_chest_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + uint viewerCount() @trusted nothrow { + auto _ret = __import_viewerCount(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]ender-chest-block-entity.viewer-count") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:ender_chest_block_entity.viewer_count") + static private extern(C) uint __import_viewerCount(uint) nothrow; + } +} + +/++ + ++/ +struct FurnaceBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]furnace-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:furnace_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]furnace-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:furnace_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + ContainerBlockEntity getContainer() @trusted nothrow { + auto _ret = __import_getContainer(this.__handle); + auto _handle0 = ContainerBlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]furnace-block-entity.get-container") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:furnace_block_entity.get_container") + static private extern(C) uint __import_getContainer(uint) nothrow; + + /++ + + +/ + ushort getCookingTimeSpent() @trusted nothrow { + auto _ret = __import_getCookingTimeSpent(this.__handle); + return cast(ushort)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]furnace-block-entity.get-cooking-time-spent") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:furnace_block_entity.get_cooking_time_spent") + static private extern(C) uint __import_getCookingTimeSpent(uint) nothrow; + + /++ + + +/ + ushort getCookingTotalTime() @trusted nothrow { + auto _ret = __import_getCookingTotalTime(this.__handle); + return cast(ushort)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]furnace-block-entity.get-cooking-total-time") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:furnace_block_entity.get_cooking_total_time") + static private extern(C) uint __import_getCookingTotalTime(uint) nothrow; + + /++ + + +/ + ushort getLitTimeRemaining() @trusted nothrow { + auto _ret = __import_getLitTimeRemaining(this.__handle); + return cast(ushort)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]furnace-block-entity.get-lit-time-remaining") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:furnace_block_entity.get_lit_time_remaining") + static private extern(C) uint __import_getLitTimeRemaining(uint) nothrow; + + /++ + + +/ + ushort getLitTotalTime() @trusted nothrow { + auto _ret = __import_getLitTotalTime(this.__handle); + return cast(ushort)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]furnace-block-entity.get-lit-total-time") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:furnace_block_entity.get_lit_total_time") + static private extern(C) uint __import_getLitTotalTime(uint) nothrow; + + /++ + + +/ + bool isBurning() @trusted nothrow { + auto _ret = __import_isBurning(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]furnace-block-entity.is-burning") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:furnace_block_entity.is_burning") + static private extern(C) uint __import_isBurning(uint) nothrow; + } +} + +/++ + ++/ +struct HopperBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]hopper-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:hopper_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]hopper-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:hopper_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + ContainerBlockEntity getContainer() @trusted nothrow { + auto _ret = __import_getContainer(this.__handle); + auto _handle0 = ContainerBlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]hopper-block-entity.get-container") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:hopper_block_entity.get_container") + static private extern(C) uint __import_getContainer(uint) nothrow; + + /++ + + +/ + int getCooldown() @trusted nothrow { + auto _ret = __import_getCooldown(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]hopper-block-entity.get-cooldown") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:hopper_block_entity.get_cooldown") + static private extern(C) uint __import_getCooldown(uint) nothrow; + } +} + +/++ + ++/ +struct JigsawBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]jigsaw-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:jigsaw_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]jigsaw-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:jigsaw_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + WitString getName() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getName(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]jigsaw-block-entity.get-name") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:jigsaw_block_entity.get_name") + static private extern(C) void __import_getName(uint, void*) nothrow; + + /++ + + +/ + WitString getTarget() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getTarget(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]jigsaw-block-entity.get-target") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:jigsaw_block_entity.get_target") + static private extern(C) void __import_getTarget(uint, void*) nothrow; + + /++ + + +/ + WitString getPool() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getPool(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]jigsaw-block-entity.get-pool") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:jigsaw_block_entity.get_pool") + static private extern(C) void __import_getPool(uint, void*) nothrow; + + /++ + + +/ + WitString getFinalState() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getFinalState(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]jigsaw-block-entity.get-final-state") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:jigsaw_block_entity.get_final_state") + static private extern(C) void __import_getFinalState(uint, void*) nothrow; + + /++ + + +/ + int getSelectionPriority() @trusted nothrow { + auto _ret = __import_getSelectionPriority(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]jigsaw-block-entity.get-selection-priority") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:jigsaw_block_entity.get_selection_priority") + static private extern(C) uint __import_getSelectionPriority(uint) nothrow; + + /++ + + +/ + int getPlacementPriority() @trusted nothrow { + auto _ret = __import_getPlacementPriority(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]jigsaw-block-entity.get-placement-priority") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:jigsaw_block_entity.get_placement_priority") + static private extern(C) uint __import_getPlacementPriority(uint) nothrow; + } +} + +/++ + ++/ +struct LecternBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]lectern-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:lectern_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]lectern-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:lectern_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + ContainerBlockEntity getContainer() @trusted nothrow { + auto _ret = __import_getContainer(this.__handle); + auto _handle0 = ContainerBlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]lectern-block-entity.get-container") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:lectern_block_entity.get_container") + static private extern(C) uint __import_getContainer(uint) nothrow; + + /++ + + +/ + uint getPage() @trusted nothrow { + auto _ret = __import_getPage(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]lectern-block-entity.get-page") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:lectern_block_entity.get_page") + static private extern(C) uint __import_getPage(uint) nothrow; + } +} + +/++ + ++/ +struct PistonBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]piston-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:piston_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]piston-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:piston_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + float getProgress() @trusted nothrow { + auto _ret = __import_getProgress(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]piston-block-entity.get-progress") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:piston_block_entity.get_progress") + static private extern(C) float __import_getProgress(uint) nothrow; + + /++ + + +/ + bool isExtending() @trusted nothrow { + auto _ret = __import_isExtending(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]piston-block-entity.is-extending") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:piston_block_entity.is_extending") + static private extern(C) uint __import_isExtending(uint) nothrow; + + /++ + + +/ + bool isSource() @trusted nothrow { + auto _ret = __import_isSource(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]piston-block-entity.is-source") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:piston_block_entity.is_source") + static private extern(C) uint __import_isSource(uint) nothrow; + } +} + +/++ + ++/ +struct PotentSulfurBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]potent-sulfur-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:potent_sulfur_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]potent-sulfur-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:potent_sulfur_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + } +} + +/++ + ++/ +struct SculkCatalystBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]sculk-catalyst-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:sculk_catalyst_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]sculk-catalyst-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:sculk_catalyst_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + } +} + +/++ + ++/ +struct SculkSensorBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]sculk-sensor-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:sculk_sensor_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]sculk-sensor-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:sculk_sensor_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + } +} + +/++ + ++/ +struct SculkShriekerBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]sculk-shrieker-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:sculk_shrieker_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]sculk-shrieker-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:sculk_shrieker_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + int getWarningLevel() @trusted nothrow { + auto _ret = __import_getWarningLevel(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]sculk-shrieker-block-entity.get-warning-level") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:sculk_shrieker_block_entity.get_warning_level") + static private extern(C) uint __import_getWarningLevel(uint) nothrow; + } +} + +/++ + ++/ +struct ShelfBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]shelf-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:shelf_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]shelf-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:shelf_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + ContainerBlockEntity getContainer() @trusted nothrow { + auto _ret = __import_getContainer(this.__handle); + auto _handle0 = ContainerBlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]shelf-block-entity.get-container") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:shelf_block_entity.get_container") + static private extern(C) uint __import_getContainer(uint) nothrow; + } +} + +/++ + ++/ +struct ShulkerBoxBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]shulker-box-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:shulker_box_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]shulker-box-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:shulker_box_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + ContainerBlockEntity getContainer() @trusted nothrow { + auto _ret = __import_getContainer(this.__handle); + auto _handle0 = ContainerBlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]shulker-box-block-entity.get-container") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:shulker_box_block_entity.get_container") + static private extern(C) uint __import_getContainer(uint) nothrow; + + /++ + + +/ + uint viewerCount() @trusted nothrow { + auto _ret = __import_viewerCount(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]shulker-box-block-entity.viewer-count") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:shulker_box_block_entity.viewer_count") + static private extern(C) uint __import_viewerCount(uint) nothrow; + } +} + +/++ + ++/ +struct SkullBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]skull-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:skull_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]skull-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:skull_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + Option!(WitString) getNoteBlockSound() @trusted nothrow { + align(size_t.sizeof) void[(3*size_t.sizeof)] _retArea = void; + __import_getNoteBlockSound(this.__handle, _retArea.ptr); + Option!(WitString) _option4 = void; + bool _isSome4 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome4) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + + _option4 = Option!(WitString).makeSome(_list3); + } else { + _option4 = Option!(WitString).makeNone; + } + auto _flush5 = _option4; + return _flush5; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]skull-block-entity.get-note-block-sound") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:skull_block_entity.get_note_block_sound") + static private extern(C) void __import_getNoteBlockSound(uint, void*) nothrow; + } +} + +/++ + ++/ +struct SmokerBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]smoker-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:smoker_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]smoker-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:smoker_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + ContainerBlockEntity getContainer() @trusted nothrow { + auto _ret = __import_getContainer(this.__handle); + auto _handle0 = ContainerBlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]smoker-block-entity.get-container") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:smoker_block_entity.get_container") + static private extern(C) uint __import_getContainer(uint) nothrow; + + /++ + + +/ + ushort getCookingTimeSpent() @trusted nothrow { + auto _ret = __import_getCookingTimeSpent(this.__handle); + return cast(ushort)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]smoker-block-entity.get-cooking-time-spent") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:smoker_block_entity.get_cooking_time_spent") + static private extern(C) uint __import_getCookingTimeSpent(uint) nothrow; + + /++ + + +/ + ushort getCookingTotalTime() @trusted nothrow { + auto _ret = __import_getCookingTotalTime(this.__handle); + return cast(ushort)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]smoker-block-entity.get-cooking-total-time") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:smoker_block_entity.get_cooking_total_time") + static private extern(C) uint __import_getCookingTotalTime(uint) nothrow; + + /++ + + +/ + ushort getLitTimeRemaining() @trusted nothrow { + auto _ret = __import_getLitTimeRemaining(this.__handle); + return cast(ushort)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]smoker-block-entity.get-lit-time-remaining") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:smoker_block_entity.get_lit_time_remaining") + static private extern(C) uint __import_getLitTimeRemaining(uint) nothrow; + + /++ + + +/ + ushort getLitTotalTime() @trusted nothrow { + auto _ret = __import_getLitTotalTime(this.__handle); + return cast(ushort)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]smoker-block-entity.get-lit-total-time") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:smoker_block_entity.get_lit_total_time") + static private extern(C) uint __import_getLitTotalTime(uint) nothrow; + + /++ + + +/ + bool isBurning() @trusted nothrow { + auto _ret = __import_isBurning(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]smoker-block-entity.is-burning") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:smoker_block_entity.is_burning") + static private extern(C) uint __import_isBurning(uint) nothrow; + } +} + +/++ + ++/ +struct StructureBlockBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]structure-block-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:structure_block_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]structure-block-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:structure_block_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + + /++ + + +/ + WitString getName() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getName(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]structure-block-block-entity.get-name") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:structure_block_block_entity.get_name") + static private extern(C) void __import_getName(uint, void*) nothrow; + + /++ + + +/ + WitString getAuthor() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getAuthor(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]structure-block-block-entity.get-author") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:structure_block_block_entity.get_author") + static private extern(C) void __import_getAuthor(uint, void*) nothrow; + + /++ + + +/ + WitString getMode() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getMode(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]structure-block-block-entity.get-mode") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:structure_block_block_entity.get_mode") + static private extern(C) void __import_getMode(uint, void*) nothrow; + + /++ + + +/ + float getIntegrity() @trusted nothrow { + auto _ret = __import_getIntegrity(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]structure-block-block-entity.get-integrity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:structure_block_block_entity.get_integrity") + static private extern(C) float __import_getIntegrity(uint) nothrow; + + /++ + + +/ + long getSeed() @trusted nothrow { + auto _ret = __import_getSeed(this.__handle); + return cast(long)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]structure-block-block-entity.get-seed") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:structure_block_block_entity.get_seed") + static private extern(C) ulong __import_getSeed(uint) nothrow; + } +} + +/++ + ++/ +struct TestBlockBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]test-block-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:test_block_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]test-block-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:test_block_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + } +} + +/++ + ++/ +struct TestInstanceBlockBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]test-instance-block-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:test_instance_block_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]test-instance-block-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:test_instance_block_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + } +} + +/++ + ++/ +struct TrialSpawnerBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]trial-spawner-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:trial_spawner_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]trial-spawner-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:trial_spawner_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + } +} + +/++ + ++/ +struct VaultBlockEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[resource-drop]vault-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:resource_drop:vault_block_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + BlockEntity getBlockEntity() @trusted nothrow { + auto _ret = __import_getBlockEntity(this.__handle); + auto _handle0 = BlockEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/block-entity@0.1.0", "[method]vault-block-entity.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__block_entity@0.1.0__:method:vault_block_entity.get_block_entity") + static private extern(C) uint __import_getBlockEntity(uint) nothrow; + } +} + +/++ + ++/ +struct BlockEntityType { + mixin WitVariant!( + CommandBlockEntity, // commandBlockEntity + SignBlockEntity, // signBlockEntity + HangingSignBlockEntity, // hangingSignBlockEntity + JukeboxBlockEntity, // jukeboxBlockEntity + ChestBlockEntity, // chestBlockEntity + TrappedChestBlockEntity, // trappedChestBlockEntity + MobSpawnerBlockEntity, // mobSpawnerBlockEntity + MapBlockEntity, // mapBlockEntity + BannerBlockEntity, // bannerBlockEntity + BarrelBlockEntity, // barrelBlockEntity + BeaconBlockEntity, // beaconBlockEntity + BedBlockEntity, // bedBlockEntity + BeehiveBlockEntity, // beehiveBlockEntity + BellBlockEntity, // bellBlockEntity + BlastingFurnaceBlockEntity, // blastingFurnaceBlockEntity + BrewingStandBlockEntity, // brewingStandBlockEntity + BrushableBlockBlockEntity, // brushableBlockBlockEntity + CalibratedSculkSensorBlockEntity, // calibratedSculkSensorBlockEntity + CampfireBlockEntity, // campfireBlockEntity + ChiseledBookshelfBlockEntity, // chiseledBookshelfBlockEntity + ComparatorBlockEntity, // comparatorBlockEntity + ConduitBlockEntity, // conduitBlockEntity + CopperGolemStatueBlockEntity, // copperGolemStatueBlockEntity + CrafterBlockEntity, // crafterBlockEntity + CreakingHeartBlockEntity, // creakingHeartBlockEntity + DaylightDetectorBlockEntity, // daylightDetectorBlockEntity + DecoratedPotBlockEntity, // decoratedPotBlockEntity + DispenserBlockEntity, // dispenserBlockEntity + DropperBlockEntity, // dropperBlockEntity + EnchantingTableBlockEntity, // enchantingTableBlockEntity + EndGatewayBlockEntity, // endGatewayBlockEntity + EndPortalBlockEntity, // endPortalBlockEntity + EnderChestBlockEntity, // enderChestBlockEntity + FurnaceBlockEntity, // furnaceBlockEntity + HopperBlockEntity, // hopperBlockEntity + JigsawBlockEntity, // jigsawBlockEntity + LecternBlockEntity, // lecternBlockEntity + PistonBlockEntity, // pistonBlockEntity + PotentSulfurBlockEntity, // potentSulfurBlockEntity + SculkCatalystBlockEntity, // sculkCatalystBlockEntity + SculkSensorBlockEntity, // sculkSensorBlockEntity + SculkShriekerBlockEntity, // sculkShriekerBlockEntity + ShelfBlockEntity, // shelfBlockEntity + ShulkerBoxBlockEntity, // shulkerBoxBlockEntity + SkullBlockEntity, // skullBlockEntity + SmokerBlockEntity, // smokerBlockEntity + StructureBlockBlockEntity, // structureBlockBlockEntity + TestBlockBlockEntity, // testBlockBlockEntity + TestInstanceBlockBlockEntity, // testInstanceBlockBlockEntity + TrialSpawnerBlockEntity, // trialSpawnerBlockEntity + VaultBlockEntity, // vaultBlockEntity + ContainerBlockEntity, // containerBlockEntity + ); + +public: + enum Tag : ubyte { + /++ + + +/ + commandBlockEntity, + + /++ + + +/ + signBlockEntity, + + /++ + + +/ + hangingSignBlockEntity, + + /++ + + +/ + jukeboxBlockEntity, + + /++ + + +/ + chestBlockEntity, + + /++ + + +/ + trappedChestBlockEntity, + + /++ + + +/ + mobSpawnerBlockEntity, + + /++ + + +/ + mapBlockEntity, + + /++ + + +/ + bannerBlockEntity, + + /++ + + +/ + barrelBlockEntity, + + /++ + + +/ + beaconBlockEntity, + + /++ + + +/ + bedBlockEntity, + + /++ + + +/ + beehiveBlockEntity, + + /++ + + +/ + bellBlockEntity, + + /++ + + +/ + blastingFurnaceBlockEntity, + + /++ + + +/ + brewingStandBlockEntity, + + /++ + + +/ + brushableBlockBlockEntity, + + /++ + + +/ + calibratedSculkSensorBlockEntity, + + /++ + + +/ + campfireBlockEntity, + + /++ + + +/ + chiseledBookshelfBlockEntity, + + /++ + + +/ + comparatorBlockEntity, + + /++ + + +/ + conduitBlockEntity, + + /++ + + +/ + copperGolemStatueBlockEntity, + + /++ + + +/ + crafterBlockEntity, + + /++ + + +/ + creakingHeartBlockEntity, + + /++ + + +/ + daylightDetectorBlockEntity, + + /++ + + +/ + decoratedPotBlockEntity, + + /++ + + +/ + dispenserBlockEntity, + + /++ + + +/ + dropperBlockEntity, + + /++ + + +/ + enchantingTableBlockEntity, + + /++ + + +/ + endGatewayBlockEntity, + + /++ + + +/ + endPortalBlockEntity, + + /++ + + +/ + enderChestBlockEntity, + + /++ + + +/ + furnaceBlockEntity, + + /++ + + +/ + hopperBlockEntity, + + /++ + + +/ + jigsawBlockEntity, + + /++ + + +/ + lecternBlockEntity, + + /++ + + +/ + pistonBlockEntity, + + /++ + + +/ + potentSulfurBlockEntity, + + /++ + + +/ + sculkCatalystBlockEntity, + + /++ + + +/ + sculkSensorBlockEntity, + + /++ + + +/ + sculkShriekerBlockEntity, + + /++ + + +/ + shelfBlockEntity, + + /++ + + +/ + shulkerBoxBlockEntity, + + /++ + + +/ + skullBlockEntity, + + /++ + + +/ + smokerBlockEntity, + + /++ + + +/ + structureBlockBlockEntity, + + /++ + + +/ + testBlockBlockEntity, + + /++ + + +/ + testInstanceBlockBlockEntity, + + /++ + + +/ + trialSpawnerBlockEntity, + + /++ + + +/ + vaultBlockEntity, + + /++ + + +/ + containerBlockEntity, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias commandBlockEntity = _create!(Tag.commandBlockEntity); + /// ditto + pragma(inline, true) bool isCommandBlockEntity() const => _tag == Tag.commandBlockEntity; + ///ditto + alias getCommandBlockEntity = _get!(Tag.commandBlockEntity); + + /++ + + +/ + alias signBlockEntity = _create!(Tag.signBlockEntity); + /// ditto + pragma(inline, true) bool isSignBlockEntity() const => _tag == Tag.signBlockEntity; + ///ditto + alias getSignBlockEntity = _get!(Tag.signBlockEntity); + + /++ + + +/ + alias hangingSignBlockEntity = _create!(Tag.hangingSignBlockEntity); + /// ditto + pragma(inline, true) bool isHangingSignBlockEntity() const => _tag == Tag.hangingSignBlockEntity; + ///ditto + alias getHangingSignBlockEntity = _get!(Tag.hangingSignBlockEntity); + + /++ + + +/ + alias jukeboxBlockEntity = _create!(Tag.jukeboxBlockEntity); + /// ditto + pragma(inline, true) bool isJukeboxBlockEntity() const => _tag == Tag.jukeboxBlockEntity; + ///ditto + alias getJukeboxBlockEntity = _get!(Tag.jukeboxBlockEntity); + + /++ + + +/ + alias chestBlockEntity = _create!(Tag.chestBlockEntity); + /// ditto + pragma(inline, true) bool isChestBlockEntity() const => _tag == Tag.chestBlockEntity; + ///ditto + alias getChestBlockEntity = _get!(Tag.chestBlockEntity); + + /++ + + +/ + alias trappedChestBlockEntity = _create!(Tag.trappedChestBlockEntity); + /// ditto + pragma(inline, true) bool isTrappedChestBlockEntity() const => _tag == Tag.trappedChestBlockEntity; + ///ditto + alias getTrappedChestBlockEntity = _get!(Tag.trappedChestBlockEntity); + + /++ + + +/ + alias mobSpawnerBlockEntity = _create!(Tag.mobSpawnerBlockEntity); + /// ditto + pragma(inline, true) bool isMobSpawnerBlockEntity() const => _tag == Tag.mobSpawnerBlockEntity; + ///ditto + alias getMobSpawnerBlockEntity = _get!(Tag.mobSpawnerBlockEntity); + + /++ + + +/ + alias mapBlockEntity = _create!(Tag.mapBlockEntity); + /// ditto + pragma(inline, true) bool isMapBlockEntity() const => _tag == Tag.mapBlockEntity; + ///ditto + alias getMapBlockEntity = _get!(Tag.mapBlockEntity); + + /++ + + +/ + alias bannerBlockEntity = _create!(Tag.bannerBlockEntity); + /// ditto + pragma(inline, true) bool isBannerBlockEntity() const => _tag == Tag.bannerBlockEntity; + ///ditto + alias getBannerBlockEntity = _get!(Tag.bannerBlockEntity); + + /++ + + +/ + alias barrelBlockEntity = _create!(Tag.barrelBlockEntity); + /// ditto + pragma(inline, true) bool isBarrelBlockEntity() const => _tag == Tag.barrelBlockEntity; + ///ditto + alias getBarrelBlockEntity = _get!(Tag.barrelBlockEntity); + + /++ + + +/ + alias beaconBlockEntity = _create!(Tag.beaconBlockEntity); + /// ditto + pragma(inline, true) bool isBeaconBlockEntity() const => _tag == Tag.beaconBlockEntity; + ///ditto + alias getBeaconBlockEntity = _get!(Tag.beaconBlockEntity); + + /++ + + +/ + alias bedBlockEntity = _create!(Tag.bedBlockEntity); + /// ditto + pragma(inline, true) bool isBedBlockEntity() const => _tag == Tag.bedBlockEntity; + ///ditto + alias getBedBlockEntity = _get!(Tag.bedBlockEntity); + + /++ + + +/ + alias beehiveBlockEntity = _create!(Tag.beehiveBlockEntity); + /// ditto + pragma(inline, true) bool isBeehiveBlockEntity() const => _tag == Tag.beehiveBlockEntity; + ///ditto + alias getBeehiveBlockEntity = _get!(Tag.beehiveBlockEntity); + + /++ + + +/ + alias bellBlockEntity = _create!(Tag.bellBlockEntity); + /// ditto + pragma(inline, true) bool isBellBlockEntity() const => _tag == Tag.bellBlockEntity; + ///ditto + alias getBellBlockEntity = _get!(Tag.bellBlockEntity); + + /++ + + +/ + alias blastingFurnaceBlockEntity = _create!(Tag.blastingFurnaceBlockEntity); + /// ditto + pragma(inline, true) bool isBlastingFurnaceBlockEntity() const => _tag == Tag.blastingFurnaceBlockEntity; + ///ditto + alias getBlastingFurnaceBlockEntity = _get!(Tag.blastingFurnaceBlockEntity); + + /++ + + +/ + alias brewingStandBlockEntity = _create!(Tag.brewingStandBlockEntity); + /// ditto + pragma(inline, true) bool isBrewingStandBlockEntity() const => _tag == Tag.brewingStandBlockEntity; + ///ditto + alias getBrewingStandBlockEntity = _get!(Tag.brewingStandBlockEntity); + + /++ + + +/ + alias brushableBlockBlockEntity = _create!(Tag.brushableBlockBlockEntity); + /// ditto + pragma(inline, true) bool isBrushableBlockBlockEntity() const => _tag == Tag.brushableBlockBlockEntity; + ///ditto + alias getBrushableBlockBlockEntity = _get!(Tag.brushableBlockBlockEntity); + + /++ + + +/ + alias calibratedSculkSensorBlockEntity = _create!(Tag.calibratedSculkSensorBlockEntity); + /// ditto + pragma(inline, true) bool isCalibratedSculkSensorBlockEntity() const => _tag == Tag.calibratedSculkSensorBlockEntity; + ///ditto + alias getCalibratedSculkSensorBlockEntity = _get!(Tag.calibratedSculkSensorBlockEntity); + + /++ + + +/ + alias campfireBlockEntity = _create!(Tag.campfireBlockEntity); + /// ditto + pragma(inline, true) bool isCampfireBlockEntity() const => _tag == Tag.campfireBlockEntity; + ///ditto + alias getCampfireBlockEntity = _get!(Tag.campfireBlockEntity); + + /++ + + +/ + alias chiseledBookshelfBlockEntity = _create!(Tag.chiseledBookshelfBlockEntity); + /// ditto + pragma(inline, true) bool isChiseledBookshelfBlockEntity() const => _tag == Tag.chiseledBookshelfBlockEntity; + ///ditto + alias getChiseledBookshelfBlockEntity = _get!(Tag.chiseledBookshelfBlockEntity); + + /++ + + +/ + alias comparatorBlockEntity = _create!(Tag.comparatorBlockEntity); + /// ditto + pragma(inline, true) bool isComparatorBlockEntity() const => _tag == Tag.comparatorBlockEntity; + ///ditto + alias getComparatorBlockEntity = _get!(Tag.comparatorBlockEntity); + + /++ + + +/ + alias conduitBlockEntity = _create!(Tag.conduitBlockEntity); + /// ditto + pragma(inline, true) bool isConduitBlockEntity() const => _tag == Tag.conduitBlockEntity; + ///ditto + alias getConduitBlockEntity = _get!(Tag.conduitBlockEntity); + + /++ + + +/ + alias copperGolemStatueBlockEntity = _create!(Tag.copperGolemStatueBlockEntity); + /// ditto + pragma(inline, true) bool isCopperGolemStatueBlockEntity() const => _tag == Tag.copperGolemStatueBlockEntity; + ///ditto + alias getCopperGolemStatueBlockEntity = _get!(Tag.copperGolemStatueBlockEntity); + + /++ + + +/ + alias crafterBlockEntity = _create!(Tag.crafterBlockEntity); + /// ditto + pragma(inline, true) bool isCrafterBlockEntity() const => _tag == Tag.crafterBlockEntity; + ///ditto + alias getCrafterBlockEntity = _get!(Tag.crafterBlockEntity); + + /++ + + +/ + alias creakingHeartBlockEntity = _create!(Tag.creakingHeartBlockEntity); + /// ditto + pragma(inline, true) bool isCreakingHeartBlockEntity() const => _tag == Tag.creakingHeartBlockEntity; + ///ditto + alias getCreakingHeartBlockEntity = _get!(Tag.creakingHeartBlockEntity); + + /++ + + +/ + alias daylightDetectorBlockEntity = _create!(Tag.daylightDetectorBlockEntity); + /// ditto + pragma(inline, true) bool isDaylightDetectorBlockEntity() const => _tag == Tag.daylightDetectorBlockEntity; + ///ditto + alias getDaylightDetectorBlockEntity = _get!(Tag.daylightDetectorBlockEntity); + + /++ + + +/ + alias decoratedPotBlockEntity = _create!(Tag.decoratedPotBlockEntity); + /// ditto + pragma(inline, true) bool isDecoratedPotBlockEntity() const => _tag == Tag.decoratedPotBlockEntity; + ///ditto + alias getDecoratedPotBlockEntity = _get!(Tag.decoratedPotBlockEntity); + + /++ + + +/ + alias dispenserBlockEntity = _create!(Tag.dispenserBlockEntity); + /// ditto + pragma(inline, true) bool isDispenserBlockEntity() const => _tag == Tag.dispenserBlockEntity; + ///ditto + alias getDispenserBlockEntity = _get!(Tag.dispenserBlockEntity); + + /++ + + +/ + alias dropperBlockEntity = _create!(Tag.dropperBlockEntity); + /// ditto + pragma(inline, true) bool isDropperBlockEntity() const => _tag == Tag.dropperBlockEntity; + ///ditto + alias getDropperBlockEntity = _get!(Tag.dropperBlockEntity); + + /++ + + +/ + alias enchantingTableBlockEntity = _create!(Tag.enchantingTableBlockEntity); + /// ditto + pragma(inline, true) bool isEnchantingTableBlockEntity() const => _tag == Tag.enchantingTableBlockEntity; + ///ditto + alias getEnchantingTableBlockEntity = _get!(Tag.enchantingTableBlockEntity); + + /++ + + +/ + alias endGatewayBlockEntity = _create!(Tag.endGatewayBlockEntity); + /// ditto + pragma(inline, true) bool isEndGatewayBlockEntity() const => _tag == Tag.endGatewayBlockEntity; + ///ditto + alias getEndGatewayBlockEntity = _get!(Tag.endGatewayBlockEntity); + + /++ + + +/ + alias endPortalBlockEntity = _create!(Tag.endPortalBlockEntity); + /// ditto + pragma(inline, true) bool isEndPortalBlockEntity() const => _tag == Tag.endPortalBlockEntity; + ///ditto + alias getEndPortalBlockEntity = _get!(Tag.endPortalBlockEntity); + + /++ + + +/ + alias enderChestBlockEntity = _create!(Tag.enderChestBlockEntity); + /// ditto + pragma(inline, true) bool isEnderChestBlockEntity() const => _tag == Tag.enderChestBlockEntity; + ///ditto + alias getEnderChestBlockEntity = _get!(Tag.enderChestBlockEntity); + + /++ + + +/ + alias furnaceBlockEntity = _create!(Tag.furnaceBlockEntity); + /// ditto + pragma(inline, true) bool isFurnaceBlockEntity() const => _tag == Tag.furnaceBlockEntity; + ///ditto + alias getFurnaceBlockEntity = _get!(Tag.furnaceBlockEntity); + + /++ + + +/ + alias hopperBlockEntity = _create!(Tag.hopperBlockEntity); + /// ditto + pragma(inline, true) bool isHopperBlockEntity() const => _tag == Tag.hopperBlockEntity; + ///ditto + alias getHopperBlockEntity = _get!(Tag.hopperBlockEntity); + + /++ + + +/ + alias jigsawBlockEntity = _create!(Tag.jigsawBlockEntity); + /// ditto + pragma(inline, true) bool isJigsawBlockEntity() const => _tag == Tag.jigsawBlockEntity; + ///ditto + alias getJigsawBlockEntity = _get!(Tag.jigsawBlockEntity); + + /++ + + +/ + alias lecternBlockEntity = _create!(Tag.lecternBlockEntity); + /// ditto + pragma(inline, true) bool isLecternBlockEntity() const => _tag == Tag.lecternBlockEntity; + ///ditto + alias getLecternBlockEntity = _get!(Tag.lecternBlockEntity); + + /++ + + +/ + alias pistonBlockEntity = _create!(Tag.pistonBlockEntity); + /// ditto + pragma(inline, true) bool isPistonBlockEntity() const => _tag == Tag.pistonBlockEntity; + ///ditto + alias getPistonBlockEntity = _get!(Tag.pistonBlockEntity); + + /++ + + +/ + alias potentSulfurBlockEntity = _create!(Tag.potentSulfurBlockEntity); + /// ditto + pragma(inline, true) bool isPotentSulfurBlockEntity() const => _tag == Tag.potentSulfurBlockEntity; + ///ditto + alias getPotentSulfurBlockEntity = _get!(Tag.potentSulfurBlockEntity); + + /++ + + +/ + alias sculkCatalystBlockEntity = _create!(Tag.sculkCatalystBlockEntity); + /// ditto + pragma(inline, true) bool isSculkCatalystBlockEntity() const => _tag == Tag.sculkCatalystBlockEntity; + ///ditto + alias getSculkCatalystBlockEntity = _get!(Tag.sculkCatalystBlockEntity); + + /++ + + +/ + alias sculkSensorBlockEntity = _create!(Tag.sculkSensorBlockEntity); + /// ditto + pragma(inline, true) bool isSculkSensorBlockEntity() const => _tag == Tag.sculkSensorBlockEntity; + ///ditto + alias getSculkSensorBlockEntity = _get!(Tag.sculkSensorBlockEntity); + + /++ + + +/ + alias sculkShriekerBlockEntity = _create!(Tag.sculkShriekerBlockEntity); + /// ditto + pragma(inline, true) bool isSculkShriekerBlockEntity() const => _tag == Tag.sculkShriekerBlockEntity; + ///ditto + alias getSculkShriekerBlockEntity = _get!(Tag.sculkShriekerBlockEntity); + + /++ + + +/ + alias shelfBlockEntity = _create!(Tag.shelfBlockEntity); + /// ditto + pragma(inline, true) bool isShelfBlockEntity() const => _tag == Tag.shelfBlockEntity; + ///ditto + alias getShelfBlockEntity = _get!(Tag.shelfBlockEntity); + + /++ + + +/ + alias shulkerBoxBlockEntity = _create!(Tag.shulkerBoxBlockEntity); + /// ditto + pragma(inline, true) bool isShulkerBoxBlockEntity() const => _tag == Tag.shulkerBoxBlockEntity; + ///ditto + alias getShulkerBoxBlockEntity = _get!(Tag.shulkerBoxBlockEntity); + + /++ + + +/ + alias skullBlockEntity = _create!(Tag.skullBlockEntity); + /// ditto + pragma(inline, true) bool isSkullBlockEntity() const => _tag == Tag.skullBlockEntity; + ///ditto + alias getSkullBlockEntity = _get!(Tag.skullBlockEntity); + + /++ + + +/ + alias smokerBlockEntity = _create!(Tag.smokerBlockEntity); + /// ditto + pragma(inline, true) bool isSmokerBlockEntity() const => _tag == Tag.smokerBlockEntity; + ///ditto + alias getSmokerBlockEntity = _get!(Tag.smokerBlockEntity); + + /++ + + +/ + alias structureBlockBlockEntity = _create!(Tag.structureBlockBlockEntity); + /// ditto + pragma(inline, true) bool isStructureBlockBlockEntity() const => _tag == Tag.structureBlockBlockEntity; + ///ditto + alias getStructureBlockBlockEntity = _get!(Tag.structureBlockBlockEntity); + + /++ + + +/ + alias testBlockBlockEntity = _create!(Tag.testBlockBlockEntity); + /// ditto + pragma(inline, true) bool isTestBlockBlockEntity() const => _tag == Tag.testBlockBlockEntity; + ///ditto + alias getTestBlockBlockEntity = _get!(Tag.testBlockBlockEntity); + + /++ + + +/ + alias testInstanceBlockBlockEntity = _create!(Tag.testInstanceBlockBlockEntity); + /// ditto + pragma(inline, true) bool isTestInstanceBlockBlockEntity() const => _tag == Tag.testInstanceBlockBlockEntity; + ///ditto + alias getTestInstanceBlockBlockEntity = _get!(Tag.testInstanceBlockBlockEntity); + + /++ + + +/ + alias trialSpawnerBlockEntity = _create!(Tag.trialSpawnerBlockEntity); + /// ditto + pragma(inline, true) bool isTrialSpawnerBlockEntity() const => _tag == Tag.trialSpawnerBlockEntity; + ///ditto + alias getTrialSpawnerBlockEntity = _get!(Tag.trialSpawnerBlockEntity); + + /++ + + +/ + alias vaultBlockEntity = _create!(Tag.vaultBlockEntity); + /// ditto + pragma(inline, true) bool isVaultBlockEntity() const => _tag == Tag.vaultBlockEntity; + ///ditto + alias getVaultBlockEntity = _get!(Tag.vaultBlockEntity); + + /++ + + +/ + alias containerBlockEntity = _create!(Tag.containerBlockEntity); + /// ditto + pragma(inline, true) bool isContainerBlockEntity() const => _tag == Tag.containerBlockEntity; + ///ditto + alias getContainerBlockEntity = _get!(Tag.containerBlockEntity); + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + switch (_tag) with (Tag) { + case commandBlockEntity: _get!(Tag.commandBlockEntity).witDrop; break; + case signBlockEntity: _get!(Tag.signBlockEntity).witDrop; break; + case hangingSignBlockEntity: _get!(Tag.hangingSignBlockEntity).witDrop; break; + case jukeboxBlockEntity: _get!(Tag.jukeboxBlockEntity).witDrop; break; + case chestBlockEntity: _get!(Tag.chestBlockEntity).witDrop; break; + case trappedChestBlockEntity: _get!(Tag.trappedChestBlockEntity).witDrop; break; + case mobSpawnerBlockEntity: _get!(Tag.mobSpawnerBlockEntity).witDrop; break; + case mapBlockEntity: _get!(Tag.mapBlockEntity).witDrop; break; + case bannerBlockEntity: _get!(Tag.bannerBlockEntity).witDrop; break; + case barrelBlockEntity: _get!(Tag.barrelBlockEntity).witDrop; break; + case beaconBlockEntity: _get!(Tag.beaconBlockEntity).witDrop; break; + case bedBlockEntity: _get!(Tag.bedBlockEntity).witDrop; break; + case beehiveBlockEntity: _get!(Tag.beehiveBlockEntity).witDrop; break; + case bellBlockEntity: _get!(Tag.bellBlockEntity).witDrop; break; + case blastingFurnaceBlockEntity: _get!(Tag.blastingFurnaceBlockEntity).witDrop; break; + case brewingStandBlockEntity: _get!(Tag.brewingStandBlockEntity).witDrop; break; + case brushableBlockBlockEntity: _get!(Tag.brushableBlockBlockEntity).witDrop; break; + case calibratedSculkSensorBlockEntity: _get!(Tag.calibratedSculkSensorBlockEntity).witDrop; break; + case campfireBlockEntity: _get!(Tag.campfireBlockEntity).witDrop; break; + case chiseledBookshelfBlockEntity: _get!(Tag.chiseledBookshelfBlockEntity).witDrop; break; + case comparatorBlockEntity: _get!(Tag.comparatorBlockEntity).witDrop; break; + case conduitBlockEntity: _get!(Tag.conduitBlockEntity).witDrop; break; + case copperGolemStatueBlockEntity: _get!(Tag.copperGolemStatueBlockEntity).witDrop; break; + case crafterBlockEntity: _get!(Tag.crafterBlockEntity).witDrop; break; + case creakingHeartBlockEntity: _get!(Tag.creakingHeartBlockEntity).witDrop; break; + case daylightDetectorBlockEntity: _get!(Tag.daylightDetectorBlockEntity).witDrop; break; + case decoratedPotBlockEntity: _get!(Tag.decoratedPotBlockEntity).witDrop; break; + case dispenserBlockEntity: _get!(Tag.dispenserBlockEntity).witDrop; break; + case dropperBlockEntity: _get!(Tag.dropperBlockEntity).witDrop; break; + case enchantingTableBlockEntity: _get!(Tag.enchantingTableBlockEntity).witDrop; break; + case endGatewayBlockEntity: _get!(Tag.endGatewayBlockEntity).witDrop; break; + case endPortalBlockEntity: _get!(Tag.endPortalBlockEntity).witDrop; break; + case enderChestBlockEntity: _get!(Tag.enderChestBlockEntity).witDrop; break; + case furnaceBlockEntity: _get!(Tag.furnaceBlockEntity).witDrop; break; + case hopperBlockEntity: _get!(Tag.hopperBlockEntity).witDrop; break; + case jigsawBlockEntity: _get!(Tag.jigsawBlockEntity).witDrop; break; + case lecternBlockEntity: _get!(Tag.lecternBlockEntity).witDrop; break; + case pistonBlockEntity: _get!(Tag.pistonBlockEntity).witDrop; break; + case potentSulfurBlockEntity: _get!(Tag.potentSulfurBlockEntity).witDrop; break; + case sculkCatalystBlockEntity: _get!(Tag.sculkCatalystBlockEntity).witDrop; break; + case sculkSensorBlockEntity: _get!(Tag.sculkSensorBlockEntity).witDrop; break; + case sculkShriekerBlockEntity: _get!(Tag.sculkShriekerBlockEntity).witDrop; break; + case shelfBlockEntity: _get!(Tag.shelfBlockEntity).witDrop; break; + case shulkerBoxBlockEntity: _get!(Tag.shulkerBoxBlockEntity).witDrop; break; + case skullBlockEntity: _get!(Tag.skullBlockEntity).witDrop; break; + case smokerBlockEntity: _get!(Tag.smokerBlockEntity).witDrop; break; + case structureBlockBlockEntity: _get!(Tag.structureBlockBlockEntity).witDrop; break; + case testBlockBlockEntity: _get!(Tag.testBlockBlockEntity).witDrop; break; + case testInstanceBlockBlockEntity: _get!(Tag.testInstanceBlockBlockEntity).witDrop; break; + case trialSpawnerBlockEntity: _get!(Tag.trialSpawnerBlockEntity).witDrop; break; + case vaultBlockEntity: _get!(Tag.vaultBlockEntity).witDrop; break; + case containerBlockEntity: _get!(Tag.containerBlockEntity).witDrop; break; + default: break; + } + } + + BlockEntityType witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.commandBlockEntity: return _create!(Tag.commandBlockEntity)(this._get!(Tag.commandBlockEntity).witClone); break; + case Tag.signBlockEntity: return _create!(Tag.signBlockEntity)(this._get!(Tag.signBlockEntity).witClone); break; + case Tag.hangingSignBlockEntity: return _create!(Tag.hangingSignBlockEntity)(this._get!(Tag.hangingSignBlockEntity).witClone); break; + case Tag.jukeboxBlockEntity: return _create!(Tag.jukeboxBlockEntity)(this._get!(Tag.jukeboxBlockEntity).witClone); break; + case Tag.chestBlockEntity: return _create!(Tag.chestBlockEntity)(this._get!(Tag.chestBlockEntity).witClone); break; + case Tag.trappedChestBlockEntity: return _create!(Tag.trappedChestBlockEntity)(this._get!(Tag.trappedChestBlockEntity).witClone); break; + case Tag.mobSpawnerBlockEntity: return _create!(Tag.mobSpawnerBlockEntity)(this._get!(Tag.mobSpawnerBlockEntity).witClone); break; + case Tag.mapBlockEntity: return _create!(Tag.mapBlockEntity)(this._get!(Tag.mapBlockEntity).witClone); break; + case Tag.bannerBlockEntity: return _create!(Tag.bannerBlockEntity)(this._get!(Tag.bannerBlockEntity).witClone); break; + case Tag.barrelBlockEntity: return _create!(Tag.barrelBlockEntity)(this._get!(Tag.barrelBlockEntity).witClone); break; + case Tag.beaconBlockEntity: return _create!(Tag.beaconBlockEntity)(this._get!(Tag.beaconBlockEntity).witClone); break; + case Tag.bedBlockEntity: return _create!(Tag.bedBlockEntity)(this._get!(Tag.bedBlockEntity).witClone); break; + case Tag.beehiveBlockEntity: return _create!(Tag.beehiveBlockEntity)(this._get!(Tag.beehiveBlockEntity).witClone); break; + case Tag.bellBlockEntity: return _create!(Tag.bellBlockEntity)(this._get!(Tag.bellBlockEntity).witClone); break; + case Tag.blastingFurnaceBlockEntity: return _create!(Tag.blastingFurnaceBlockEntity)(this._get!(Tag.blastingFurnaceBlockEntity).witClone); break; + case Tag.brewingStandBlockEntity: return _create!(Tag.brewingStandBlockEntity)(this._get!(Tag.brewingStandBlockEntity).witClone); break; + case Tag.brushableBlockBlockEntity: return _create!(Tag.brushableBlockBlockEntity)(this._get!(Tag.brushableBlockBlockEntity).witClone); break; + case Tag.calibratedSculkSensorBlockEntity: return _create!(Tag.calibratedSculkSensorBlockEntity)(this._get!(Tag.calibratedSculkSensorBlockEntity).witClone); break; + case Tag.campfireBlockEntity: return _create!(Tag.campfireBlockEntity)(this._get!(Tag.campfireBlockEntity).witClone); break; + case Tag.chiseledBookshelfBlockEntity: return _create!(Tag.chiseledBookshelfBlockEntity)(this._get!(Tag.chiseledBookshelfBlockEntity).witClone); break; + case Tag.comparatorBlockEntity: return _create!(Tag.comparatorBlockEntity)(this._get!(Tag.comparatorBlockEntity).witClone); break; + case Tag.conduitBlockEntity: return _create!(Tag.conduitBlockEntity)(this._get!(Tag.conduitBlockEntity).witClone); break; + case Tag.copperGolemStatueBlockEntity: return _create!(Tag.copperGolemStatueBlockEntity)(this._get!(Tag.copperGolemStatueBlockEntity).witClone); break; + case Tag.crafterBlockEntity: return _create!(Tag.crafterBlockEntity)(this._get!(Tag.crafterBlockEntity).witClone); break; + case Tag.creakingHeartBlockEntity: return _create!(Tag.creakingHeartBlockEntity)(this._get!(Tag.creakingHeartBlockEntity).witClone); break; + case Tag.daylightDetectorBlockEntity: return _create!(Tag.daylightDetectorBlockEntity)(this._get!(Tag.daylightDetectorBlockEntity).witClone); break; + case Tag.decoratedPotBlockEntity: return _create!(Tag.decoratedPotBlockEntity)(this._get!(Tag.decoratedPotBlockEntity).witClone); break; + case Tag.dispenserBlockEntity: return _create!(Tag.dispenserBlockEntity)(this._get!(Tag.dispenserBlockEntity).witClone); break; + case Tag.dropperBlockEntity: return _create!(Tag.dropperBlockEntity)(this._get!(Tag.dropperBlockEntity).witClone); break; + case Tag.enchantingTableBlockEntity: return _create!(Tag.enchantingTableBlockEntity)(this._get!(Tag.enchantingTableBlockEntity).witClone); break; + case Tag.endGatewayBlockEntity: return _create!(Tag.endGatewayBlockEntity)(this._get!(Tag.endGatewayBlockEntity).witClone); break; + case Tag.endPortalBlockEntity: return _create!(Tag.endPortalBlockEntity)(this._get!(Tag.endPortalBlockEntity).witClone); break; + case Tag.enderChestBlockEntity: return _create!(Tag.enderChestBlockEntity)(this._get!(Tag.enderChestBlockEntity).witClone); break; + case Tag.furnaceBlockEntity: return _create!(Tag.furnaceBlockEntity)(this._get!(Tag.furnaceBlockEntity).witClone); break; + case Tag.hopperBlockEntity: return _create!(Tag.hopperBlockEntity)(this._get!(Tag.hopperBlockEntity).witClone); break; + case Tag.jigsawBlockEntity: return _create!(Tag.jigsawBlockEntity)(this._get!(Tag.jigsawBlockEntity).witClone); break; + case Tag.lecternBlockEntity: return _create!(Tag.lecternBlockEntity)(this._get!(Tag.lecternBlockEntity).witClone); break; + case Tag.pistonBlockEntity: return _create!(Tag.pistonBlockEntity)(this._get!(Tag.pistonBlockEntity).witClone); break; + case Tag.potentSulfurBlockEntity: return _create!(Tag.potentSulfurBlockEntity)(this._get!(Tag.potentSulfurBlockEntity).witClone); break; + case Tag.sculkCatalystBlockEntity: return _create!(Tag.sculkCatalystBlockEntity)(this._get!(Tag.sculkCatalystBlockEntity).witClone); break; + case Tag.sculkSensorBlockEntity: return _create!(Tag.sculkSensorBlockEntity)(this._get!(Tag.sculkSensorBlockEntity).witClone); break; + case Tag.sculkShriekerBlockEntity: return _create!(Tag.sculkShriekerBlockEntity)(this._get!(Tag.sculkShriekerBlockEntity).witClone); break; + case Tag.shelfBlockEntity: return _create!(Tag.shelfBlockEntity)(this._get!(Tag.shelfBlockEntity).witClone); break; + case Tag.shulkerBoxBlockEntity: return _create!(Tag.shulkerBoxBlockEntity)(this._get!(Tag.shulkerBoxBlockEntity).witClone); break; + case Tag.skullBlockEntity: return _create!(Tag.skullBlockEntity)(this._get!(Tag.skullBlockEntity).witClone); break; + case Tag.smokerBlockEntity: return _create!(Tag.smokerBlockEntity)(this._get!(Tag.smokerBlockEntity).witClone); break; + case Tag.structureBlockBlockEntity: return _create!(Tag.structureBlockBlockEntity)(this._get!(Tag.structureBlockBlockEntity).witClone); break; + case Tag.testBlockBlockEntity: return _create!(Tag.testBlockBlockEntity)(this._get!(Tag.testBlockBlockEntity).witClone); break; + case Tag.testInstanceBlockBlockEntity: return _create!(Tag.testInstanceBlockBlockEntity)(this._get!(Tag.testInstanceBlockBlockEntity).witClone); break; + case Tag.trialSpawnerBlockEntity: return _create!(Tag.trialSpawnerBlockEntity)(this._get!(Tag.trialSpawnerBlockEntity).witClone); break; + case Tag.vaultBlockEntity: return _create!(Tag.vaultBlockEntity)(this._get!(Tag.vaultBlockEntity).witClone); break; + case Tag.containerBlockEntity: return _create!(Tag.containerBlockEntity)(this._get!(Tag.containerBlockEntity).witClone); break; + } + } +} diff --git a/src/wit/pumpkin/plugin/boss_bar/common.d b/src/wit/pumpkin/plugin/boss_bar/common.d new file mode 100644 index 0000000..ca6ce16 --- /dev/null +++ b/src/wit/pumpkin/plugin/boss_bar/common.d @@ -0,0 +1,114 @@ +/++ + ++/ +module wit.pumpkin.plugin.boss_bar.common; + + +import wit.common; + +static import wit.pumpkin.plugin.text.common; +static import wit.pumpkin.plugin.player.common; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ +Represents the color of a boss bar. ++/ +enum BossBarColor : ubyte { + /++ + + +/ + pink, + + /++ + + +/ + blue, + + /++ + + +/ + red, + + /++ + + +/ + green, + + /++ + + +/ + yellow, + + /++ + + +/ + purple, + + /++ + + +/ + white, +} +/++ +Represents the notches/divisions of a boss bar. ++/ +enum BossBarDivision : ubyte { + /++ + + +/ + noDivision, + + /++ + + +/ + notches6, + + /++ + + +/ + notches10, + + /++ + + +/ + notches12, + + /++ + + +/ + notches20, +} +/++ +Metadata flags that can be toggled on a boss bar. ++/ +struct BossBarMetadata { + /++ + Darkens the sky for players who see the boss bar. + +/ + bool darkenSky; + + /++ + If true, the bar is considered a "dragon bar" (used for Ender Dragon). + +/ + bool dragonBar; + + /++ + If true, fog is created around the players who see the boss bar. + +/ + bool createFog; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + BossBarMetadata witClone() const @nogc nothrow { + BossBarMetadata clone = void; + clone.darkenSky = this.darkenSky.witClone; + clone.dragonBar = this.dragonBar.witClone; + clone.createFog = this.createFog.witClone; + return clone; + } +} diff --git a/src/wit/pumpkin/plugin/boss_bar/imports.d b/src/wit/pumpkin/plugin/boss_bar/imports.d new file mode 100644 index 0000000..ca315a8 --- /dev/null +++ b/src/wit/pumpkin/plugin/boss_bar/imports.d @@ -0,0 +1,253 @@ +/++ + ++/ +module wit.pumpkin.plugin.boss_bar.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.boss_bar.common; + +static import wit.pumpkin.plugin.text.imports; +static import wit.pumpkin.plugin.player.imports; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias TextComponent = wit.pumpkin.plugin.text.imports.TextComponent; + +/++ + ++/ +alias Player = wit.pumpkin.plugin.player.imports.Player; + +/++ +Represents a boss bar that can be shown to players. ++/ +struct BossBar { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + /++ + Creates a new boss bar. + +/ + static BossBar makeNew(TextComponent title, BossBarColor color, BossBarDivision division) @trusted nothrow { + auto _ret = __import_makeNew(title.__handle, cast(uint)(color), cast(uint)(division)); + auto _handle0 = BossBar(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/boss-bar@0.1.0", "[constructor]boss-bar") + pragma(mangle, "__wit_import_pumpkin:plugin__boss_bar@0.1.0__:constructor:boss_bar") + static private extern(C) uint __import_makeNew(uint, uint, uint) nothrow; + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/boss-bar@0.1.0", "[resource-drop]boss-bar") + pragma(mangle, "__wit_import_pumpkin:plugin__boss_bar@0.1.0__:resource_drop:boss_bar") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + Returns the title of this boss bar. + +/ + TextComponent getTitle() @trusted nothrow { + auto _ret = __import_getTitle(this.__handle); + auto _handle0 = TextComponent(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/boss-bar@0.1.0", "[method]boss-bar.get-title") + pragma(mangle, "__wit_import_pumpkin:plugin__boss_bar@0.1.0__:method:boss_bar.get_title") + static private extern(C) uint __import_getTitle(uint) nothrow; + + /++ + Sets the title of this boss bar. + +/ + void setTitle(TextComponent title) @trusted nothrow { + __import_setTitle(this.__handle, title.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/boss-bar@0.1.0", "[method]boss-bar.set-title") + pragma(mangle, "__wit_import_pumpkin:plugin__boss_bar@0.1.0__:method:boss_bar.set_title") + static private extern(C) void __import_setTitle(uint, uint) nothrow; + + /++ + Returns the health (0.0 to 1.0) of this boss bar. + +/ + float getHealth() @trusted nothrow { + auto _ret = __import_getHealth(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/boss-bar@0.1.0", "[method]boss-bar.get-health") + pragma(mangle, "__wit_import_pumpkin:plugin__boss_bar@0.1.0__:method:boss_bar.get_health") + static private extern(C) float __import_getHealth(uint) nothrow; + + /++ + Sets the health (0.0 to 1.0) of this boss bar. + +/ + void setHealth(float health) @trusted nothrow { + __import_setHealth(this.__handle, health); + } + /// ditto + @wasmImport!("pumpkin:plugin/boss-bar@0.1.0", "[method]boss-bar.set-health") + pragma(mangle, "__wit_import_pumpkin:plugin__boss_bar@0.1.0__:method:boss_bar.set_health") + static private extern(C) void __import_setHealth(uint, float) nothrow; + + /++ + Returns the color of this boss bar. + +/ + BossBarColor getColor() @trusted nothrow { + auto _ret = __import_getColor(this.__handle); + return cast(BossBarColor)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/boss-bar@0.1.0", "[method]boss-bar.get-color") + pragma(mangle, "__wit_import_pumpkin:plugin__boss_bar@0.1.0__:method:boss_bar.get_color") + static private extern(C) uint __import_getColor(uint) nothrow; + + /++ + Sets the color of this boss bar. + +/ + void setColor(BossBarColor color) @trusted nothrow { + __import_setColor(this.__handle, cast(uint)(color)); + } + /// ditto + @wasmImport!("pumpkin:plugin/boss-bar@0.1.0", "[method]boss-bar.set-color") + pragma(mangle, "__wit_import_pumpkin:plugin__boss_bar@0.1.0__:method:boss_bar.set_color") + static private extern(C) void __import_setColor(uint, uint) nothrow; + + /++ + Returns the division of this boss bar. + +/ + BossBarDivision getDivision() @trusted nothrow { + auto _ret = __import_getDivision(this.__handle); + return cast(BossBarDivision)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/boss-bar@0.1.0", "[method]boss-bar.get-division") + pragma(mangle, "__wit_import_pumpkin:plugin__boss_bar@0.1.0__:method:boss_bar.get_division") + static private extern(C) uint __import_getDivision(uint) nothrow; + + /++ + Sets the division of this boss bar. + +/ + void setDivision(BossBarDivision division) @trusted nothrow { + __import_setDivision(this.__handle, cast(uint)(division)); + } + /// ditto + @wasmImport!("pumpkin:plugin/boss-bar@0.1.0", "[method]boss-bar.set-division") + pragma(mangle, "__wit_import_pumpkin:plugin__boss_bar@0.1.0__:method:boss_bar.set_division") + static private extern(C) void __import_setDivision(uint, uint) nothrow; + + /++ + Returns the currently active metadata on this boss bar. + +/ + BossBarMetadata getMetadata() @trusted nothrow { + align(1) void[3] _retArea = void; + __import_getMetadata(this.__handle, _retArea.ptr); + BossBarMetadata _record0 = { + darkenSky: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0, + dragonBar: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 1)))) != 0, + createFog: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 2)))) != 0, + }; + auto _flush1 = _record0; + return _flush1; + } + /// ditto + @wasmImport!("pumpkin:plugin/boss-bar@0.1.0", "[method]boss-bar.get-metadata") + pragma(mangle, "__wit_import_pumpkin:plugin__boss_bar@0.1.0__:method:boss_bar.get_metadata") + static private extern(C) void __import_getMetadata(uint, void*) nothrow; + + /++ + Updates the metadata on this boss bar. + +/ + void setMetadata(in BossBarMetadata metadata) @trusted nothrow { + __import_setMetadata(this.__handle, cast(uint)(metadata.darkenSky), cast(uint)(metadata.dragonBar), cast(uint)(metadata.createFog)); + } + /// ditto + @wasmImport!("pumpkin:plugin/boss-bar@0.1.0", "[method]boss-bar.set-metadata") + pragma(mangle, "__wit_import_pumpkin:plugin__boss_bar@0.1.0__:method:boss_bar.set_metadata") + static private extern(C) void __import_setMetadata(uint, uint, uint, uint) nothrow; + + /++ + Adds a player to this boss bar, making it visible to them. + +/ + void addPlayer(Player player) @trusted nothrow { + __import_addPlayer(this.__handle, player.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/boss-bar@0.1.0", "[method]boss-bar.add-player") + pragma(mangle, "__wit_import_pumpkin:plugin__boss_bar@0.1.0__:method:boss_bar.add_player") + static private extern(C) void __import_addPlayer(uint, uint) nothrow; + + /++ + Removes a player from this boss bar, hiding it from them. + +/ + void removePlayer(Player player) @trusted nothrow { + __import_removePlayer(this.__handle, player.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/boss-bar@0.1.0", "[method]boss-bar.remove-player") + pragma(mangle, "__wit_import_pumpkin:plugin__boss_bar@0.1.0__:method:boss_bar.remove_player") + static private extern(C) void __import_removePlayer(uint, uint) nothrow; + + /++ + Returns a list of all players currently seeing this boss bar. + +/ + WitList!(Player) getPlayers() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getPlayers(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(Player*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitList!(Player)(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/boss-bar@0.1.0", "[method]boss-bar.get-players") + pragma(mangle, "__wit_import_pumpkin:plugin__boss_bar@0.1.0__:method:boss_bar.get_players") + static private extern(C) void __import_getPlayers(uint, void*) nothrow; + + /++ + Removes this boss bar from all players and cleans it up. + +/ + void removeAll() @trusted nothrow { + __import_removeAll(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/boss-bar@0.1.0", "[method]boss-bar.remove-all") + pragma(mangle, "__wit_import_pumpkin:plugin__boss_bar@0.1.0__:method:boss_bar.remove_all") + static private extern(C) void __import_removeAll(uint) nothrow; + } +} diff --git a/src/wit/pumpkin/plugin/command/common.d b/src/wit/pumpkin/plugin/command/common.d new file mode 100644 index 0000000..713daf8 --- /dev/null +++ b/src/wit/pumpkin/plugin/command/common.d @@ -0,0 +1,1261 @@ +/++ + ++/ +module wit.pumpkin.plugin.command.common; + + +import wit.common; + +static import wit.pumpkin.plugin.common.common; +static import wit.pumpkin.plugin.text.common; +static import wit.pumpkin.plugin.item_stack.common; +static import wit.pumpkin.plugin.block_entity.common; +static import wit.pumpkin.plugin.world.common; +static import wit.pumpkin.plugin.player.common; +static import wit.pumpkin.plugin.server.common; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias Position = wit.pumpkin.plugin.common.common.Position; + +/++ + ++/ +alias BlockPos = wit.pumpkin.plugin.common.common.BlockPos; + +/++ + ++/ +alias Locale = wit.pumpkin.plugin.common.common.Locale; + +/++ + ++/ +alias GameMode = wit.pumpkin.plugin.common.common.GameMode; + +/++ + ++/ +alias Difficulty = wit.pumpkin.plugin.server.common.Difficulty; + +/++ + ++/ +struct SuggestionRequest { + /++ + + +/ + WitString input; + + /++ + + +/ + uint cursor; + + /++ + + +/ + uint start; + + /++ + + +/ + WitString remaining; + + void witFree() @nogc nothrow { + input.witFree; + remaining.witFree; + } + + void witDrop() @nogc nothrow { + } + + SuggestionRequest witClone() const @nogc nothrow { + SuggestionRequest clone = void; + clone.input = this.input.witClone; + clone.cursor = this.cursor.witClone; + clone.start = this.start.witClone; + clone.remaining = this.remaining.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityArgument { + /++ + + +/ + bool single; + + /++ + + +/ + bool playersOnly; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityArgument witClone() const @nogc nothrow { + EntityArgument clone = void; + clone.single = this.single.witClone; + clone.playersOnly = this.playersOnly.witClone; + return clone; + } +} + +/++ + ++/ +enum PermissionLevel : ubyte { + /++ + + +/ + zero, + + /++ + + +/ + one, + + /++ + + +/ + two, + + /++ + + +/ + three, + + /++ + + +/ + four, +} +/++ + ++/ +enum StringType : ubyte { + /++ + + +/ + singleWord, + + /++ + + +/ + quotable, + + /++ + + +/ + greedy, +} +/++ + ++/ +struct ArgumentType { + mixin WitVariant!( + void, // bool_ + Tuple!(Option!(float), Option!(float)), // float_ + Tuple!(Option!(double), Option!(double)), // double_ + Tuple!(Option!(int), Option!(int)), // integer + Tuple!(Option!(long), Option!(long)), // long_ + StringType, // string + void, // entities + void, // entity + void, // players + void, // gameProfile + void, // blockPos + void, // columnPos + void, // position3d + void, // position2d + void, // blockState + void, // blockPredicate + void, // item + void, // itemPredicate + void, // color + void, // component + void, // style + void, // message + void, // nbtCompoundTag + void, // nbtTag + void, // nbtPath + void, // objective + void, // objectiveCriteria + void, // operation + void, // particle + void, // angle + void, // rotation + void, // scoreboardSlot + bool, // scoreHolder + void, // swizzle + void, // team + void, // itemSlot + void, // resourceLocation + void, // mobEffect + void, // function_ + void, // entityAnchor + void, // intRange + void, // floatRange + void, // dimension + void, // gamemode + void, // difficulty + Option!(int), // time + WitString, // resource + WitString, // resourceOrTag + WitString, // resourceOrTagKey + WitString, // resourceKey + void, // templateMirror + void, // templateRotation + void, // uuid + ); + +public: + enum Tag : ubyte { + /++ + + +/ + bool_, + + /++ + + +/ + float_, + + /++ + + +/ + double_, + + /++ + + +/ + integer, + + /++ + + +/ + long_, + + /++ + + +/ + string, + + /++ + + +/ + entities, + + /++ + + +/ + entity, + + /++ + + +/ + players, + + /++ + + +/ + gameProfile, + + /++ + + +/ + blockPos, + + /++ + + +/ + columnPos, + + /++ + + +/ + position3d, + + /++ + + +/ + position2d, + + /++ + + +/ + blockState, + + /++ + + +/ + blockPredicate, + + /++ + + +/ + item, + + /++ + + +/ + itemPredicate, + + /++ + + +/ + color, + + /++ + + +/ + component, + + /++ + + +/ + style, + + /++ + + +/ + message, + + /++ + + +/ + nbtCompoundTag, + + /++ + + +/ + nbtTag, + + /++ + + +/ + nbtPath, + + /++ + + +/ + objective, + + /++ + + +/ + objectiveCriteria, + + /++ + + +/ + operation, + + /++ + + +/ + particle, + + /++ + + +/ + angle, + + /++ + + +/ + rotation, + + /++ + + +/ + scoreboardSlot, + + /++ + + +/ + scoreHolder, + + /++ + + +/ + swizzle, + + /++ + + +/ + team, + + /++ + + +/ + itemSlot, + + /++ + + +/ + resourceLocation, + + /++ + + +/ + mobEffect, + + /++ + + +/ + function_, + + /++ + + +/ + entityAnchor, + + /++ + + +/ + intRange, + + /++ + + +/ + floatRange, + + /++ + + +/ + dimension, + + /++ + + +/ + gamemode, + + /++ + + +/ + difficulty, + + /++ + + +/ + time, + + /++ + + +/ + resource, + + /++ + + +/ + resourceOrTag, + + /++ + + +/ + resourceOrTagKey, + + /++ + + +/ + resourceKey, + + /++ + + +/ + templateMirror, + + /++ + + +/ + templateRotation, + + /++ + + +/ + uuid, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias bool_ = _create!(Tag.bool_); + /// ditto + pragma(inline, true) bool isBool() const => _tag == Tag.bool_; + + /++ + + +/ + alias float_ = _create!(Tag.float_); + /// ditto + pragma(inline, true) bool isFloat() const => _tag == Tag.float_; + ///ditto + alias getFloat = _get!(Tag.float_); + + /++ + + +/ + alias double_ = _create!(Tag.double_); + /// ditto + pragma(inline, true) bool isDouble() const => _tag == Tag.double_; + ///ditto + alias getDouble = _get!(Tag.double_); + + /++ + + +/ + alias integer = _create!(Tag.integer); + /// ditto + pragma(inline, true) bool isInteger() const => _tag == Tag.integer; + ///ditto + alias getInteger = _get!(Tag.integer); + + /++ + + +/ + alias long_ = _create!(Tag.long_); + /// ditto + pragma(inline, true) bool isLong() const => _tag == Tag.long_; + ///ditto + alias getLong = _get!(Tag.long_); + + /++ + + +/ + alias string = _create!(Tag.string); + /// ditto + pragma(inline, true) bool isString() const => _tag == Tag.string; + ///ditto + alias getString = _get!(Tag.string); + + /++ + + +/ + alias entities = _create!(Tag.entities); + /// ditto + pragma(inline, true) bool isEntities() const => _tag == Tag.entities; + + /++ + + +/ + alias entity = _create!(Tag.entity); + /// ditto + pragma(inline, true) bool isEntity() const => _tag == Tag.entity; + + /++ + + +/ + alias players = _create!(Tag.players); + /// ditto + pragma(inline, true) bool isPlayers() const => _tag == Tag.players; + + /++ + + +/ + alias gameProfile = _create!(Tag.gameProfile); + /// ditto + pragma(inline, true) bool isGameProfile() const => _tag == Tag.gameProfile; + + /++ + + +/ + alias blockPos = _create!(Tag.blockPos); + /// ditto + pragma(inline, true) bool isBlockPos() const => _tag == Tag.blockPos; + + /++ + + +/ + alias columnPos = _create!(Tag.columnPos); + /// ditto + pragma(inline, true) bool isColumnPos() const => _tag == Tag.columnPos; + + /++ + + +/ + alias position3d = _create!(Tag.position3d); + /// ditto + pragma(inline, true) bool isPosition3d() const => _tag == Tag.position3d; + + /++ + + +/ + alias position2d = _create!(Tag.position2d); + /// ditto + pragma(inline, true) bool isPosition2d() const => _tag == Tag.position2d; + + /++ + + +/ + alias blockState = _create!(Tag.blockState); + /// ditto + pragma(inline, true) bool isBlockState() const => _tag == Tag.blockState; + + /++ + + +/ + alias blockPredicate = _create!(Tag.blockPredicate); + /// ditto + pragma(inline, true) bool isBlockPredicate() const => _tag == Tag.blockPredicate; + + /++ + + +/ + alias item = _create!(Tag.item); + /// ditto + pragma(inline, true) bool isItem() const => _tag == Tag.item; + + /++ + + +/ + alias itemPredicate = _create!(Tag.itemPredicate); + /// ditto + pragma(inline, true) bool isItemPredicate() const => _tag == Tag.itemPredicate; + + /++ + + +/ + alias color = _create!(Tag.color); + /// ditto + pragma(inline, true) bool isColor() const => _tag == Tag.color; + + /++ + + +/ + alias component = _create!(Tag.component); + /// ditto + pragma(inline, true) bool isComponent() const => _tag == Tag.component; + + /++ + + +/ + alias style = _create!(Tag.style); + /// ditto + pragma(inline, true) bool isStyle() const => _tag == Tag.style; + + /++ + + +/ + alias message = _create!(Tag.message); + /// ditto + pragma(inline, true) bool isMessage() const => _tag == Tag.message; + + /++ + + +/ + alias nbtCompoundTag = _create!(Tag.nbtCompoundTag); + /// ditto + pragma(inline, true) bool isNbtCompoundTag() const => _tag == Tag.nbtCompoundTag; + + /++ + + +/ + alias nbtTag = _create!(Tag.nbtTag); + /// ditto + pragma(inline, true) bool isNbtTag() const => _tag == Tag.nbtTag; + + /++ + + +/ + alias nbtPath = _create!(Tag.nbtPath); + /// ditto + pragma(inline, true) bool isNbtPath() const => _tag == Tag.nbtPath; + + /++ + + +/ + alias objective = _create!(Tag.objective); + /// ditto + pragma(inline, true) bool isObjective() const => _tag == Tag.objective; + + /++ + + +/ + alias objectiveCriteria = _create!(Tag.objectiveCriteria); + /// ditto + pragma(inline, true) bool isObjectiveCriteria() const => _tag == Tag.objectiveCriteria; + + /++ + + +/ + alias operation = _create!(Tag.operation); + /// ditto + pragma(inline, true) bool isOperation() const => _tag == Tag.operation; + + /++ + + +/ + alias particle = _create!(Tag.particle); + /// ditto + pragma(inline, true) bool isParticle() const => _tag == Tag.particle; + + /++ + + +/ + alias angle = _create!(Tag.angle); + /// ditto + pragma(inline, true) bool isAngle() const => _tag == Tag.angle; + + /++ + + +/ + alias rotation = _create!(Tag.rotation); + /// ditto + pragma(inline, true) bool isRotation() const => _tag == Tag.rotation; + + /++ + + +/ + alias scoreboardSlot = _create!(Tag.scoreboardSlot); + /// ditto + pragma(inline, true) bool isScoreboardSlot() const => _tag == Tag.scoreboardSlot; + + /++ + + +/ + alias scoreHolder = _create!(Tag.scoreHolder); + /// ditto + pragma(inline, true) bool isScoreHolder() const => _tag == Tag.scoreHolder; + ///ditto + alias getScoreHolder = _get!(Tag.scoreHolder); + + /++ + + +/ + alias swizzle = _create!(Tag.swizzle); + /// ditto + pragma(inline, true) bool isSwizzle() const => _tag == Tag.swizzle; + + /++ + + +/ + alias team = _create!(Tag.team); + /// ditto + pragma(inline, true) bool isTeam() const => _tag == Tag.team; + + /++ + + +/ + alias itemSlot = _create!(Tag.itemSlot); + /// ditto + pragma(inline, true) bool isItemSlot() const => _tag == Tag.itemSlot; + + /++ + + +/ + alias resourceLocation = _create!(Tag.resourceLocation); + /// ditto + pragma(inline, true) bool isResourceLocation() const => _tag == Tag.resourceLocation; + + /++ + + +/ + alias mobEffect = _create!(Tag.mobEffect); + /// ditto + pragma(inline, true) bool isMobEffect() const => _tag == Tag.mobEffect; + + /++ + + +/ + alias function_ = _create!(Tag.function_); + /// ditto + pragma(inline, true) bool isFunction() const => _tag == Tag.function_; + + /++ + + +/ + alias entityAnchor = _create!(Tag.entityAnchor); + /// ditto + pragma(inline, true) bool isEntityAnchor() const => _tag == Tag.entityAnchor; + + /++ + + +/ + alias intRange = _create!(Tag.intRange); + /// ditto + pragma(inline, true) bool isIntRange() const => _tag == Tag.intRange; + + /++ + + +/ + alias floatRange = _create!(Tag.floatRange); + /// ditto + pragma(inline, true) bool isFloatRange() const => _tag == Tag.floatRange; + + /++ + + +/ + alias dimension = _create!(Tag.dimension); + /// ditto + pragma(inline, true) bool isDimension() const => _tag == Tag.dimension; + + /++ + + +/ + alias gamemode = _create!(Tag.gamemode); + /// ditto + pragma(inline, true) bool isGamemode() const => _tag == Tag.gamemode; + + /++ + + +/ + alias difficulty = _create!(Tag.difficulty); + /// ditto + pragma(inline, true) bool isDifficulty() const => _tag == Tag.difficulty; + + /++ + + +/ + alias time = _create!(Tag.time); + /// ditto + pragma(inline, true) bool isTime() const => _tag == Tag.time; + ///ditto + alias getTime = _get!(Tag.time); + + /++ + + +/ + alias resource = _create!(Tag.resource); + /// ditto + pragma(inline, true) bool isResource() const => _tag == Tag.resource; + ///ditto + alias getResource = _get!(Tag.resource); + + /++ + + +/ + alias resourceOrTag = _create!(Tag.resourceOrTag); + /// ditto + pragma(inline, true) bool isResourceOrTag() const => _tag == Tag.resourceOrTag; + ///ditto + alias getResourceOrTag = _get!(Tag.resourceOrTag); + + /++ + + +/ + alias resourceOrTagKey = _create!(Tag.resourceOrTagKey); + /// ditto + pragma(inline, true) bool isResourceOrTagKey() const => _tag == Tag.resourceOrTagKey; + ///ditto + alias getResourceOrTagKey = _get!(Tag.resourceOrTagKey); + + /++ + + +/ + alias resourceKey = _create!(Tag.resourceKey); + /// ditto + pragma(inline, true) bool isResourceKey() const => _tag == Tag.resourceKey; + ///ditto + alias getResourceKey = _get!(Tag.resourceKey); + + /++ + + +/ + alias templateMirror = _create!(Tag.templateMirror); + /// ditto + pragma(inline, true) bool isTemplateMirror() const => _tag == Tag.templateMirror; + + /++ + + +/ + alias templateRotation = _create!(Tag.templateRotation); + /// ditto + pragma(inline, true) bool isTemplateRotation() const => _tag == Tag.templateRotation; + + /++ + + +/ + alias uuid = _create!(Tag.uuid); + /// ditto + pragma(inline, true) bool isUuid() const => _tag == Tag.uuid; + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case resource: _get!(Tag.resource).witFree; break; + case resourceOrTag: _get!(Tag.resourceOrTag).witFree; break; + case resourceOrTagKey: _get!(Tag.resourceOrTagKey).witFree; break; + case resourceKey: _get!(Tag.resourceKey).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + } + + ArgumentType witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.bool_: return _create!(Tag.bool_); break; + case Tag.float_: return _create!(Tag.float_)(this._get!(Tag.float_).witClone); break; + case Tag.double_: return _create!(Tag.double_)(this._get!(Tag.double_).witClone); break; + case Tag.integer: return _create!(Tag.integer)(this._get!(Tag.integer).witClone); break; + case Tag.long_: return _create!(Tag.long_)(this._get!(Tag.long_).witClone); break; + case Tag.string: return _create!(Tag.string)(this._get!(Tag.string).witClone); break; + case Tag.entities: return _create!(Tag.entities); break; + case Tag.entity: return _create!(Tag.entity); break; + case Tag.players: return _create!(Tag.players); break; + case Tag.gameProfile: return _create!(Tag.gameProfile); break; + case Tag.blockPos: return _create!(Tag.blockPos); break; + case Tag.columnPos: return _create!(Tag.columnPos); break; + case Tag.position3d: return _create!(Tag.position3d); break; + case Tag.position2d: return _create!(Tag.position2d); break; + case Tag.blockState: return _create!(Tag.blockState); break; + case Tag.blockPredicate: return _create!(Tag.blockPredicate); break; + case Tag.item: return _create!(Tag.item); break; + case Tag.itemPredicate: return _create!(Tag.itemPredicate); break; + case Tag.color: return _create!(Tag.color); break; + case Tag.component: return _create!(Tag.component); break; + case Tag.style: return _create!(Tag.style); break; + case Tag.message: return _create!(Tag.message); break; + case Tag.nbtCompoundTag: return _create!(Tag.nbtCompoundTag); break; + case Tag.nbtTag: return _create!(Tag.nbtTag); break; + case Tag.nbtPath: return _create!(Tag.nbtPath); break; + case Tag.objective: return _create!(Tag.objective); break; + case Tag.objectiveCriteria: return _create!(Tag.objectiveCriteria); break; + case Tag.operation: return _create!(Tag.operation); break; + case Tag.particle: return _create!(Tag.particle); break; + case Tag.angle: return _create!(Tag.angle); break; + case Tag.rotation: return _create!(Tag.rotation); break; + case Tag.scoreboardSlot: return _create!(Tag.scoreboardSlot); break; + case Tag.scoreHolder: return _create!(Tag.scoreHolder)(this._get!(Tag.scoreHolder).witClone); break; + case Tag.swizzle: return _create!(Tag.swizzle); break; + case Tag.team: return _create!(Tag.team); break; + case Tag.itemSlot: return _create!(Tag.itemSlot); break; + case Tag.resourceLocation: return _create!(Tag.resourceLocation); break; + case Tag.mobEffect: return _create!(Tag.mobEffect); break; + case Tag.function_: return _create!(Tag.function_); break; + case Tag.entityAnchor: return _create!(Tag.entityAnchor); break; + case Tag.intRange: return _create!(Tag.intRange); break; + case Tag.floatRange: return _create!(Tag.floatRange); break; + case Tag.dimension: return _create!(Tag.dimension); break; + case Tag.gamemode: return _create!(Tag.gamemode); break; + case Tag.difficulty: return _create!(Tag.difficulty); break; + case Tag.time: return _create!(Tag.time)(this._get!(Tag.time).witClone); break; + case Tag.resource: return _create!(Tag.resource)(this._get!(Tag.resource).witClone); break; + case Tag.resourceOrTag: return _create!(Tag.resourceOrTag)(this._get!(Tag.resourceOrTag).witClone); break; + case Tag.resourceOrTagKey: return _create!(Tag.resourceOrTagKey)(this._get!(Tag.resourceOrTagKey).witClone); break; + case Tag.resourceKey: return _create!(Tag.resourceKey)(this._get!(Tag.resourceKey).witClone); break; + case Tag.templateMirror: return _create!(Tag.templateMirror); break; + case Tag.templateRotation: return _create!(Tag.templateRotation); break; + case Tag.uuid: return _create!(Tag.uuid); break; + } + } +} + +/++ + ++/ +enum SuggestionType : ubyte { + /++ + + +/ + askServer, + + /++ + + +/ + allRecipes, + + /++ + + +/ + availableSounds, + + /++ + + +/ + availableBiomes, + + /++ + + +/ + summonableEntities, +} +/++ + ++/ +enum BossbarColor : ubyte { + /++ + + +/ + pink, + + /++ + + +/ + blue, + + /++ + + +/ + red, + + /++ + + +/ + green, + + /++ + + +/ + yellow, + + /++ + + +/ + purple, + + /++ + + +/ + white, +} +/++ + ++/ +enum BossbarStyle : ubyte { + /++ + + +/ + noDivision, + + /++ + + +/ + notches6, + + /++ + + +/ + notches10, + + /++ + + +/ + notches12, + + /++ + + +/ + notches20, +} +/++ + ++/ +enum SoundCategory : ubyte { + /++ + + +/ + master, + + /++ + + +/ + music, + + /++ + + +/ + records, + + /++ + + +/ + weather, + + /++ + + +/ + blocks, + + /++ + + +/ + hostile, + + /++ + + +/ + neutral, + + /++ + + +/ + players, + + /++ + + +/ + ambient, + + /++ + + +/ + voice, +} +/++ + ++/ +enum EntityAnchor : ubyte { + /++ + + +/ + eyes, + + /++ + + +/ + feet, +} +/++ + ++/ +struct Number { + mixin WitVariant!( + double, // float64 + float, // float32 + int, // int32 + long, // int64 + ); + +public: + enum Tag : ubyte { + /++ + + +/ + float64, + + /++ + + +/ + float32, + + /++ + + +/ + int32, + + /++ + + +/ + int64, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias float64 = _create!(Tag.float64); + /// ditto + pragma(inline, true) bool isFloat64() const => _tag == Tag.float64; + ///ditto + alias getFloat64 = _get!(Tag.float64); + + /++ + + +/ + alias float32 = _create!(Tag.float32); + /// ditto + pragma(inline, true) bool isFloat32() const => _tag == Tag.float32; + ///ditto + alias getFloat32 = _get!(Tag.float32); + + /++ + + +/ + alias int32 = _create!(Tag.int32); + /// ditto + pragma(inline, true) bool isInt32() const => _tag == Tag.int32; + ///ditto + alias getInt32 = _get!(Tag.int32); + + /++ + + +/ + alias int64 = _create!(Tag.int64); + /// ditto + pragma(inline, true) bool isInt64() const => _tag == Tag.int64; + ///ditto + alias getInt64 = _get!(Tag.int64); + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + Number witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.float64: return _create!(Tag.float64)(this._get!(Tag.float64).witClone); break; + case Tag.float32: return _create!(Tag.float32)(this._get!(Tag.float32).witClone); break; + case Tag.int32: return _create!(Tag.int32)(this._get!(Tag.int32).witClone); break; + case Tag.int64: return _create!(Tag.int64)(this._get!(Tag.int64).witClone); break; + } + } +} + +/++ + ++/ +struct NotInBounds { + mixin WitVariant!( + Tuple!(Number, Number), // lowerBound + Tuple!(Number, Number), // upperBound + ); + +public: + enum Tag : ubyte { + /++ + + +/ + lowerBound, + + /++ + + +/ + upperBound, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias lowerBound = _create!(Tag.lowerBound); + /// ditto + pragma(inline, true) bool isLowerBound() const => _tag == Tag.lowerBound; + ///ditto + alias getLowerBound = _get!(Tag.lowerBound); + + /++ + + +/ + alias upperBound = _create!(Tag.upperBound); + /// ditto + pragma(inline, true) bool isUpperBound() const => _tag == Tag.upperBound; + ///ditto + alias getUpperBound = _get!(Tag.upperBound); + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + NotInBounds witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.lowerBound: return _create!(Tag.lowerBound)(this._get!(Tag.lowerBound).witClone); break; + case Tag.upperBound: return _create!(Tag.upperBound)(this._get!(Tag.upperBound).witClone); break; + } + } +} diff --git a/src/wit/pumpkin/plugin/command/imports.d b/src/wit/pumpkin/plugin/command/imports.d new file mode 100644 index 0000000..fba7223 --- /dev/null +++ b/src/wit/pumpkin/plugin/command/imports.d @@ -0,0 +1,2272 @@ +/++ + ++/ +module wit.pumpkin.plugin.command.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.command.common; + +static import wit.pumpkin.plugin.common.imports; +static import wit.pumpkin.plugin.text.imports; +static import wit.pumpkin.plugin.item_stack.imports; +static import wit.pumpkin.plugin.block_entity.imports; +static import wit.pumpkin.plugin.world.imports; +static import wit.pumpkin.plugin.player.imports; +static import wit.pumpkin.plugin.server.imports; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias World = wit.pumpkin.plugin.world.imports.World; + +/++ + ++/ +alias Entity = wit.pumpkin.plugin.world.imports.Entity; + +/++ + ++/ +alias Player = wit.pumpkin.plugin.player.imports.Player; + +/++ + ++/ +alias CommandBlockEntity = wit.pumpkin.plugin.block_entity.imports.CommandBlockEntity; + +/++ + ++/ +alias ItemStack = wit.pumpkin.plugin.item_stack.imports.ItemStack; + +/++ + ++/ +alias Server = wit.pumpkin.plugin.server.imports.Server; + +/++ + ++/ +alias TextComponent = wit.pumpkin.plugin.text.imports.TextComponent; + +/++ + ++/ +struct CommandError { + mixin WitVariant!( + Option!(WitString), // invalidConsumption + void, // invalidRequirement + void, // permissionDenied + TextComponent, // commandFailed + ); + +public: + enum Tag : ubyte { + /++ + + +/ + invalidConsumption, + + /++ + + +/ + invalidRequirement, + + /++ + + +/ + permissionDenied, + + /++ + + +/ + commandFailed, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias invalidConsumption = _create!(Tag.invalidConsumption); + /// ditto + pragma(inline, true) bool isInvalidConsumption() const => _tag == Tag.invalidConsumption; + ///ditto + alias getInvalidConsumption = _get!(Tag.invalidConsumption); + + /++ + + +/ + alias invalidRequirement = _create!(Tag.invalidRequirement); + /// ditto + pragma(inline, true) bool isInvalidRequirement() const => _tag == Tag.invalidRequirement; + + /++ + + +/ + alias permissionDenied = _create!(Tag.permissionDenied); + /// ditto + pragma(inline, true) bool isPermissionDenied() const => _tag == Tag.permissionDenied; + + /++ + + +/ + alias commandFailed = _create!(Tag.commandFailed); + /// ditto + pragma(inline, true) bool isCommandFailed() const => _tag == Tag.commandFailed; + ///ditto + alias getCommandFailed = _get!(Tag.commandFailed); + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case invalidConsumption: _get!(Tag.invalidConsumption).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + switch (_tag) with (Tag) { + case commandFailed: _get!(Tag.commandFailed).witDrop; break; + default: break; + } + } + + CommandError witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.invalidConsumption: return _create!(Tag.invalidConsumption)(this._get!(Tag.invalidConsumption).witClone); break; + case Tag.invalidRequirement: return _create!(Tag.invalidRequirement); break; + case Tag.permissionDenied: return _create!(Tag.permissionDenied); break; + case Tag.commandFailed: return _create!(Tag.commandFailed)(this._get!(Tag.commandFailed).witClone); break; + } + } +} + +/++ + ++/ +struct CommandNode { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + /++ + + +/ + static CommandNode literal(in WitString name) @trusted nothrow { + auto _ret = __import_literal(cast(void*)(name.ptr), name.length); + auto _handle0 = CommandNode(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[static]command-node.literal") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:static:command_node.literal") + static private extern(C) uint __import_literal(void*, size_t) nothrow; + + /++ + + +/ + static CommandNode argument(in WitString name, in ArgumentType type) @trusted nothrow { + uint _variantPart160 = void; + void* _variantPart161 = void; + ulong _variantPart162 = void; + uint _variantPart163 = void; + ulong _variantPart164 = void; + alias _Tag165 = ArgumentType.Tag; + final switch (type.tag) { + case _Tag165.bool_: { + _variantPart160 = 0; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.float_: { + const ref Tuple!(Option!(float), Option!(float)) _payload3 = type.getFloat(); + uint _option8 = void; + float _option9 = void; + if (_payload3[0].isSome) { + ref _payload7 = _payload3[0].unwrap(); + _option8 = 1; + _option9 = _payload7; + } else { + _option8 = 0; + _option9 = 0; + } + uint _option14 = void; + float _option15 = void; + if (_payload3[1].isSome) { + ref _payload13 = _payload3[1].unwrap(); + _option14 = 1; + _option15 = _payload13; + } else { + _option14 = 0; + _option15 = 0; + } + _variantPart160 = 1; + _variantPart161 = cast(void*)(_option8); + _variantPart162 = (_option9).reinterpretCast!uint; + _variantPart163 = _option14; + _variantPart164 = (_option15).reinterpretCast!uint; + break; + } + case _Tag165.double_: { + const ref Tuple!(Option!(double), Option!(double)) _payload17 = type.getDouble(); + uint _option22 = void; + double _option23 = void; + if (_payload17[0].isSome) { + ref _payload21 = _payload17[0].unwrap(); + _option22 = 1; + _option23 = _payload21; + } else { + _option22 = 0; + _option23 = 0; + } + uint _option28 = void; + double _option29 = void; + if (_payload17[1].isSome) { + ref _payload27 = _payload17[1].unwrap(); + _option28 = 1; + _option29 = _payload27; + } else { + _option28 = 0; + _option29 = 0; + } + _variantPart160 = 2; + _variantPart161 = cast(void*)(_option22); + _variantPart162 = (_option23).reinterpretCast!ulong; + _variantPart163 = _option28; + _variantPart164 = (_option29).reinterpretCast!ulong; + break; + } + case _Tag165.integer: { + const ref Tuple!(Option!(int), Option!(int)) _payload31 = type.getInteger(); + uint _option36 = void; + uint _option37 = void; + if (_payload31[0].isSome) { + ref _payload35 = _payload31[0].unwrap(); + _option36 = 1; + _option37 = cast(uint)(_payload35); + } else { + _option36 = 0; + _option37 = 0; + } + uint _option42 = void; + uint _option43 = void; + if (_payload31[1].isSome) { + ref _payload41 = _payload31[1].unwrap(); + _option42 = 1; + _option43 = cast(uint)(_payload41); + } else { + _option42 = 0; + _option43 = 0; + } + _variantPart160 = 3; + _variantPart161 = cast(void*)(_option36); + _variantPart162 = cast(ulong)(_option37); + _variantPart163 = _option42; + _variantPart164 = cast(ulong)(_option43); + break; + } + case _Tag165.long_: { + const ref Tuple!(Option!(long), Option!(long)) _payload45 = type.getLong(); + uint _option50 = void; + ulong _option51 = void; + if (_payload45[0].isSome) { + ref _payload49 = _payload45[0].unwrap(); + _option50 = 1; + _option51 = cast(ulong)(_payload49); + } else { + _option50 = 0; + _option51 = 0; + } + uint _option56 = void; + ulong _option57 = void; + if (_payload45[1].isSome) { + ref _payload55 = _payload45[1].unwrap(); + _option56 = 1; + _option57 = cast(ulong)(_payload55); + } else { + _option56 = 0; + _option57 = 0; + } + _variantPart160 = 4; + _variantPart161 = cast(void*)(_option50); + _variantPart162 = _option51; + _variantPart163 = _option56; + _variantPart164 = _option57; + break; + } + case _Tag165.string: { + const ref StringType _payload59 = type.getString(); + _variantPart160 = 5; + _variantPart161 = cast(void*)(cast(uint)(_payload59)); + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.entities: { + _variantPart160 = 6; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.entity: { + _variantPart160 = 7; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.players: { + _variantPart160 = 8; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.gameProfile: { + _variantPart160 = 9; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.blockPos: { + _variantPart160 = 10; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.columnPos: { + _variantPart160 = 11; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.position3d: { + _variantPart160 = 12; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.position2d: { + _variantPart160 = 13; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.blockState: { + _variantPart160 = 14; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.blockPredicate: { + _variantPart160 = 15; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.item: { + _variantPart160 = 16; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.itemPredicate: { + _variantPart160 = 17; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.color: { + _variantPart160 = 18; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.component: { + _variantPart160 = 19; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.style: { + _variantPart160 = 20; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.message: { + _variantPart160 = 21; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.nbtCompoundTag: { + _variantPart160 = 22; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.nbtTag: { + _variantPart160 = 23; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.nbtPath: { + _variantPart160 = 24; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.objective: { + _variantPart160 = 25; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.objectiveCriteria: { + _variantPart160 = 26; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.operation: { + _variantPart160 = 27; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.particle: { + _variantPart160 = 28; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.angle: { + _variantPart160 = 29; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.rotation: { + _variantPart160 = 30; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.scoreboardSlot: { + _variantPart160 = 31; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.scoreHolder: { + const ref bool _payload113 = type.getScoreHolder(); + _variantPart160 = 32; + _variantPart161 = cast(void*)(cast(uint)(_payload113)); + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.swizzle: { + _variantPart160 = 33; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.team: { + _variantPart160 = 34; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.itemSlot: { + _variantPart160 = 35; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.resourceLocation: { + _variantPart160 = 36; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.mobEffect: { + _variantPart160 = 37; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.function_: { + _variantPart160 = 38; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.entityAnchor: { + _variantPart160 = 39; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.intRange: { + _variantPart160 = 40; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.floatRange: { + _variantPart160 = 41; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.dimension: { + _variantPart160 = 42; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.gamemode: { + _variantPart160 = 43; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.difficulty: { + _variantPart160 = 44; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.time: { + const ref Option!(int) _payload139 = type.getTime(); + uint _option144 = void; + uint _option145 = void; + if (_payload139.isSome) { + ref _payload143 = _payload139.unwrap(); + _option144 = 1; + _option145 = cast(uint)(_payload143); + } else { + _option144 = 0; + _option145 = 0; + } + _variantPart160 = 45; + _variantPart161 = cast(void*)(_option144); + _variantPart162 = cast(ulong)(_option145); + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.resource: { + const ref WitString _payload147 = type.getResource(); + _variantPart160 = 46; + _variantPart161 = cast(void*)(_payload147.ptr); + _variantPart162 = cast(ulong)(_payload147.length); + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.resourceOrTag: { + const ref WitString _payload149 = type.getResourceOrTag(); + _variantPart160 = 47; + _variantPart161 = cast(void*)(_payload149.ptr); + _variantPart162 = cast(ulong)(_payload149.length); + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.resourceOrTagKey: { + const ref WitString _payload151 = type.getResourceOrTagKey(); + _variantPart160 = 48; + _variantPart161 = cast(void*)(_payload151.ptr); + _variantPart162 = cast(ulong)(_payload151.length); + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.resourceKey: { + const ref WitString _payload153 = type.getResourceKey(); + _variantPart160 = 49; + _variantPart161 = cast(void*)(_payload153.ptr); + _variantPart162 = cast(ulong)(_payload153.length); + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.templateMirror: { + _variantPart160 = 50; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.templateRotation: { + _variantPart160 = 51; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + case _Tag165.uuid: { + _variantPart160 = 52; + _variantPart161 = null; + _variantPart162 = 0; + _variantPart163 = 0; + _variantPart164 = 0; + break; + } + } + auto _ret = __import_argument(cast(void*)(name.ptr), name.length, _variantPart160, _variantPart161, _variantPart162, _variantPart163, _variantPart164); + auto _handle166 = CommandNode(_ret); + return _handle166; + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[static]command-node.argument") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:static:command_node.argument") + static private extern(C) uint __import_argument(void*, size_t, uint, void*, ulong, uint, ulong) nothrow; + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/command@0.1.0", "[resource-drop]command-node") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:resource_drop:command_node") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + void then(CommandNode node) @trusted nothrow { + __import_then(this.__handle, node.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]command-node.then") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:command_node.then") + static private extern(C) void __import_then(uint, uint) nothrow; + + /++ + + +/ + void executeWithHandlerId(uint handlerId) @trusted nothrow { + __import_executeWithHandlerId(this.__handle, handlerId); + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]command-node.execute-with-handler-id") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:command_node.execute_with_handler_id") + static private extern(C) void __import_executeWithHandlerId(uint, uint) nothrow; + + /++ + + +/ + void suggestWithHandlerId(uint handlerId) @trusted nothrow { + __import_suggestWithHandlerId(this.__handle, handlerId); + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]command-node.suggest-with-handler-id") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:command_node.suggest_with_handler_id") + static private extern(C) void __import_suggestWithHandlerId(uint, uint) nothrow; + + /++ + + +/ + void requireWithHandlerId(uint handlerId) @trusted nothrow { + __import_requireWithHandlerId(this.__handle, handlerId); + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]command-node.require-with-handler-id") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:command_node.require_with_handler_id") + static private extern(C) void __import_requireWithHandlerId(uint, uint) nothrow; + } +} + +/++ + ++/ +struct CommandSuggestion { + /++ + + +/ + WitString value; + + /++ + + +/ + Option!(TextComponent) tooltip; + + void witFree() @nogc nothrow { + value.witFree; + } + + void witDrop() @nogc nothrow { + tooltip.witDrop; + } + + CommandSuggestion witClone() const @nogc nothrow { + CommandSuggestion clone = void; + clone.value = this.value.witClone; + clone.tooltip = this.tooltip.witClone; + return clone; + } +} + +/++ + ++/ +struct CommandSuggestions { + /++ + + +/ + uint start; + + /++ + + +/ + uint length; + + /++ + + +/ + WitList!(CommandSuggestion) values; + + void witFree() @nogc nothrow { + values.witFree; + } + + void witDrop() @nogc nothrow { + values.witDrop; + } + + CommandSuggestions witClone() const @nogc nothrow { + CommandSuggestions clone = void; + clone.start = this.start.witClone; + clone.length = this.length.witClone; + clone.values = this.values.witClone; + return clone; + } +} + +/++ + ++/ +struct CommandSenderType { + mixin WitVariant!( + void, // rcon + void, // console + Player, // player + Tuple!(CommandBlockEntity, World), // commandBlock + void, // dummy + ); + +public: + enum Tag : ubyte { + /++ + + +/ + rcon, + + /++ + + +/ + console, + + /++ + + +/ + player, + + /++ + + +/ + commandBlock, + + /++ + + +/ + dummy, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias rcon = _create!(Tag.rcon); + /// ditto + pragma(inline, true) bool isRcon() const => _tag == Tag.rcon; + + /++ + + +/ + alias console = _create!(Tag.console); + /// ditto + pragma(inline, true) bool isConsole() const => _tag == Tag.console; + + /++ + + +/ + alias player = _create!(Tag.player); + /// ditto + pragma(inline, true) bool isPlayer() const => _tag == Tag.player; + ///ditto + alias getPlayer = _get!(Tag.player); + + /++ + + +/ + alias commandBlock = _create!(Tag.commandBlock); + /// ditto + pragma(inline, true) bool isCommandBlock() const => _tag == Tag.commandBlock; + ///ditto + alias getCommandBlock = _get!(Tag.commandBlock); + + /++ + + +/ + alias dummy = _create!(Tag.dummy); + /// ditto + pragma(inline, true) bool isDummy() const => _tag == Tag.dummy; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + switch (_tag) with (Tag) { + case player: _get!(Tag.player).witDrop; break; + case commandBlock: _get!(Tag.commandBlock).witDrop; break; + default: break; + } + } + + CommandSenderType witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.rcon: return _create!(Tag.rcon); break; + case Tag.console: return _create!(Tag.console); break; + case Tag.player: return _create!(Tag.player)(this._get!(Tag.player).witClone); break; + case Tag.commandBlock: return _create!(Tag.commandBlock)(this._get!(Tag.commandBlock).witClone); break; + case Tag.dummy: return _create!(Tag.dummy); break; + } + } +} + +/++ + ++/ +struct CommandSender { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/command@0.1.0", "[resource-drop]command-sender") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:resource_drop:command_sender") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + CommandSenderType getCommandSenderType() @trusted nothrow { + align(4) void[12] _retArea = void; + __import_getCommandSenderType(this.__handle, _retArea.ptr); + CommandSenderType _variant9 = void; + auto _tag9 = cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0))); + alias _Tag9 = CommandSenderType.Tag; + final switch (cast(CommandSenderType.Tag)_tag9) { + case _Tag9.rcon: { + _variant9 = CommandSenderType.rcon(); + break; + } + case _Tag9.console: { + _variant9 = CommandSenderType.console(); + break; + } + case _Tag9.player: { + auto _handle3 = Player(*(cast(uint*)(_retArea.ptr + 4))); + auto _payload12 = _handle3; + _variant9 = CommandSenderType.player(_payload12); + break; + } + case _Tag9.commandBlock: { + auto _handle5 = CommandBlockEntity(*(cast(uint*)(_retArea.ptr + 4))); + auto _handle6 = World(*(cast(uint*)(_retArea.ptr + 8))); + auto _tuple7 = Tuple!(CommandBlockEntity, World)( + _handle5, + _handle6, + ); + auto _payload13 = _tuple7; + _variant9 = CommandSenderType.commandBlock(_payload13); + break; + } + case _Tag9.dummy: { + _variant9 = CommandSenderType.dummy(); + break; + } + } + auto _flush15 = _variant9; + return _flush15; + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]command-sender.get-command-sender-type") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:command_sender.get_command_sender_type") + static private extern(C) void __import_getCommandSenderType(uint, void*) nothrow; + + /++ + + +/ + WitString getName() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getName(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]command-sender.get-name") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:command_sender.get_name") + static private extern(C) void __import_getName(uint, void*) nothrow; + + /++ + + +/ + void sendMessage(TextComponent text) @trusted nothrow { + __import_sendMessage(this.__handle, text.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]command-sender.send-message") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:command_sender.send_message") + static private extern(C) void __import_sendMessage(uint, uint) nothrow; + + /++ + + +/ + void sendSystemMessage(TextComponent text) @trusted nothrow { + __import_sendSystemMessage(this.__handle, text.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]command-sender.send-system-message") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:command_sender.send_system_message") + static private extern(C) void __import_sendSystemMessage(uint, uint) nothrow; + + /++ + + +/ + void sendError(TextComponent text) @trusted nothrow { + __import_sendError(this.__handle, text.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]command-sender.send-error") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:command_sender.send_error") + static private extern(C) void __import_sendError(uint, uint) nothrow; + + /++ + + +/ + void setSuccessCount(int count) @trusted nothrow { + __import_setSuccessCount(this.__handle, cast(uint)(count)); + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]command-sender.set-success-count") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:command_sender.set_success_count") + static private extern(C) void __import_setSuccessCount(uint, uint) nothrow; + + /++ + + +/ + bool isPlayer() @trusted nothrow { + auto _ret = __import_isPlayer(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]command-sender.is-player") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:command_sender.is_player") + static private extern(C) uint __import_isPlayer(uint) nothrow; + + /++ + + +/ + bool isConsole() @trusted nothrow { + auto _ret = __import_isConsole(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]command-sender.is-console") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:command_sender.is_console") + static private extern(C) uint __import_isConsole(uint) nothrow; + + /++ + + +/ + Option!(Player) asPlayer() @trusted nothrow { + align(4) void[8] _retArea = void; + __import_asPlayer(this.__handle, _retArea.ptr); + Option!(Player) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = Player(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(Player).makeSome(_handle2); + } else { + _option3 = Option!(Player).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]command-sender.as-player") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:command_sender.as_player") + static private extern(C) void __import_asPlayer(uint, void*) nothrow; + + /++ + + +/ + PermissionLevel permissionLevel() @trusted nothrow { + auto _ret = __import_permissionLevel(this.__handle); + return cast(PermissionLevel)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]command-sender.permission-level") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:command_sender.permission_level") + static private extern(C) uint __import_permissionLevel(uint) nothrow; + + /++ + + +/ + bool hasPermissionLevel(PermissionLevel level) @trusted nothrow { + auto _ret = __import_hasPermissionLevel(this.__handle, cast(uint)(level)); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]command-sender.has-permission-level") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:command_sender.has_permission_level") + static private extern(C) uint __import_hasPermissionLevel(uint, uint) nothrow; + + /++ + + +/ + bool hasPermission(Server.Borrow server, in WitString node) @trusted nothrow { + auto _ret = __import_hasPermission(this.__handle, server.__handle, cast(void*)(node.ptr), node.length); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]command-sender.has-permission") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:command_sender.has_permission") + static private extern(C) uint __import_hasPermission(uint, uint, void*, size_t) nothrow; + + /++ + + +/ + Option!(Position) position() @trusted nothrow { + align(8) void[32] _retArea = void; + __import_position(this.__handle, _retArea.ptr); + Option!(Position) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _tuple2 = wit.pumpkin.plugin.common.imports.Position( + *(cast(double*)(_retArea.ptr + 8)), + *(cast(double*)(_retArea.ptr + 16)), + *(cast(double*)(_retArea.ptr + 24)), + ); + + _option3 = Option!(Position).makeSome(_tuple2); + } else { + _option3 = Option!(Position).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]command-sender.position") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:command_sender.position") + static private extern(C) void __import_position(uint, void*) nothrow; + + /++ + + +/ + Option!(World) world() @trusted nothrow { + align(4) void[8] _retArea = void; + __import_world(this.__handle, _retArea.ptr); + Option!(World) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = World(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(World).makeSome(_handle2); + } else { + _option3 = Option!(World).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]command-sender.world") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:command_sender.world") + static private extern(C) void __import_world(uint, void*) nothrow; + + /++ + + +/ + Locale getLocale() @trusted nothrow { + auto _ret = __import_getLocale(this.__handle); + return cast(wit.pumpkin.plugin.common.imports.Locale)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]command-sender.get-locale") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:command_sender.get_locale") + static private extern(C) uint __import_getLocale(uint) nothrow; + + /++ + + +/ + bool shouldReceiveFeedback() @trusted nothrow { + auto _ret = __import_shouldReceiveFeedback(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]command-sender.should-receive-feedback") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:command_sender.should_receive_feedback") + static private extern(C) uint __import_shouldReceiveFeedback(uint) nothrow; + + /++ + + +/ + bool shouldBroadcastConsoleToOps() @trusted nothrow { + auto _ret = __import_shouldBroadcastConsoleToOps(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]command-sender.should-broadcast-console-to-ops") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:command_sender.should_broadcast_console_to_ops") + static private extern(C) uint __import_shouldBroadcastConsoleToOps(uint) nothrow; + + /++ + + +/ + bool shouldTrackOutput() @trusted nothrow { + auto _ret = __import_shouldTrackOutput(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]command-sender.should-track-output") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:command_sender.should_track_output") + static private extern(C) uint __import_shouldTrackOutput(uint) nothrow; + } +} + +/++ + ++/ +struct Arg { + mixin WitVariant!( + WitString, // simple + WitString, // msg + bool, // bool_ + WitString, // item + WitString, // itemPredicate + WitString, // resourceLocation + WitString, // block + WitString, // blockPredicate + int, // time + Result!(Number, NotInBounds), // num + BlockPos, // blockPos + Tuple!(double, double, double), // pos3d + Tuple!(double, double), // pos2d + Tuple!(float, bool, float, bool), // rotation + GameMode, // gamemode + Difficulty, // difficulty + WitList!(Player), // players + WitString, // particle + TextComponent, // textComponent + BossbarColor, // bossbarColor + BossbarStyle, // bossbarStyle + SoundCategory, // soundCategory + WitString, // damageType + WitString, // effect + WitString, // enchantment + WitString, // advancement + EntityAnchor, // entityAnchor + ); + +public: + enum Tag : ubyte { + /++ + + +/ + simple, + + /++ + + +/ + msg, + + /++ + + +/ + bool_, + + /++ + + +/ + item, + + /++ + + +/ + itemPredicate, + + /++ + + +/ + resourceLocation, + + /++ + + +/ + block, + + /++ + + +/ + blockPredicate, + + /++ + + +/ + time, + + /++ + + +/ + num, + + /++ + + +/ + blockPos, + + /++ + + +/ + pos3d, + + /++ + + +/ + pos2d, + + /++ + + +/ + rotation, + + /++ + + +/ + gamemode, + + /++ + + +/ + difficulty, + + /++ + + +/ + players, + + /++ + + +/ + particle, + + /++ + + +/ + textComponent, + + /++ + + +/ + bossbarColor, + + /++ + + +/ + bossbarStyle, + + /++ + + +/ + soundCategory, + + /++ + + +/ + damageType, + + /++ + + +/ + effect, + + /++ + + +/ + enchantment, + + /++ + + +/ + advancement, + + /++ + + +/ + entityAnchor, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias simple = _create!(Tag.simple); + /// ditto + pragma(inline, true) bool isSimple() const => _tag == Tag.simple; + ///ditto + alias getSimple = _get!(Tag.simple); + + /++ + + +/ + alias msg = _create!(Tag.msg); + /// ditto + pragma(inline, true) bool isMsg() const => _tag == Tag.msg; + ///ditto + alias getMsg = _get!(Tag.msg); + + /++ + + +/ + alias bool_ = _create!(Tag.bool_); + /// ditto + pragma(inline, true) bool isBool() const => _tag == Tag.bool_; + ///ditto + alias getBool = _get!(Tag.bool_); + + /++ + + +/ + alias item = _create!(Tag.item); + /// ditto + pragma(inline, true) bool isItem() const => _tag == Tag.item; + ///ditto + alias getItem = _get!(Tag.item); + + /++ + + +/ + alias itemPredicate = _create!(Tag.itemPredicate); + /// ditto + pragma(inline, true) bool isItemPredicate() const => _tag == Tag.itemPredicate; + ///ditto + alias getItemPredicate = _get!(Tag.itemPredicate); + + /++ + + +/ + alias resourceLocation = _create!(Tag.resourceLocation); + /// ditto + pragma(inline, true) bool isResourceLocation() const => _tag == Tag.resourceLocation; + ///ditto + alias getResourceLocation = _get!(Tag.resourceLocation); + + /++ + + +/ + alias block = _create!(Tag.block); + /// ditto + pragma(inline, true) bool isBlock() const => _tag == Tag.block; + ///ditto + alias getBlock = _get!(Tag.block); + + /++ + + +/ + alias blockPredicate = _create!(Tag.blockPredicate); + /// ditto + pragma(inline, true) bool isBlockPredicate() const => _tag == Tag.blockPredicate; + ///ditto + alias getBlockPredicate = _get!(Tag.blockPredicate); + + /++ + + +/ + alias time = _create!(Tag.time); + /// ditto + pragma(inline, true) bool isTime() const => _tag == Tag.time; + ///ditto + alias getTime = _get!(Tag.time); + + /++ + + +/ + alias num = _create!(Tag.num); + /// ditto + pragma(inline, true) bool isNum() const => _tag == Tag.num; + ///ditto + alias getNum = _get!(Tag.num); + + /++ + + +/ + alias blockPos = _create!(Tag.blockPos); + /// ditto + pragma(inline, true) bool isBlockPos() const => _tag == Tag.blockPos; + ///ditto + alias getBlockPos = _get!(Tag.blockPos); + + /++ + + +/ + alias pos3d = _create!(Tag.pos3d); + /// ditto + pragma(inline, true) bool isPos3d() const => _tag == Tag.pos3d; + ///ditto + alias getPos3d = _get!(Tag.pos3d); + + /++ + + +/ + alias pos2d = _create!(Tag.pos2d); + /// ditto + pragma(inline, true) bool isPos2d() const => _tag == Tag.pos2d; + ///ditto + alias getPos2d = _get!(Tag.pos2d); + + /++ + + +/ + alias rotation = _create!(Tag.rotation); + /// ditto + pragma(inline, true) bool isRotation() const => _tag == Tag.rotation; + ///ditto + alias getRotation = _get!(Tag.rotation); + + /++ + + +/ + alias gamemode = _create!(Tag.gamemode); + /// ditto + pragma(inline, true) bool isGamemode() const => _tag == Tag.gamemode; + ///ditto + alias getGamemode = _get!(Tag.gamemode); + + /++ + + +/ + alias difficulty = _create!(Tag.difficulty); + /// ditto + pragma(inline, true) bool isDifficulty() const => _tag == Tag.difficulty; + ///ditto + alias getDifficulty = _get!(Tag.difficulty); + + /++ + + +/ + alias players = _create!(Tag.players); + /// ditto + pragma(inline, true) bool isPlayers() const => _tag == Tag.players; + ///ditto + alias getPlayers = _get!(Tag.players); + + /++ + + +/ + alias particle = _create!(Tag.particle); + /// ditto + pragma(inline, true) bool isParticle() const => _tag == Tag.particle; + ///ditto + alias getParticle = _get!(Tag.particle); + + /++ + + +/ + alias textComponent = _create!(Tag.textComponent); + /// ditto + pragma(inline, true) bool isTextComponent() const => _tag == Tag.textComponent; + ///ditto + alias getTextComponent = _get!(Tag.textComponent); + + /++ + + +/ + alias bossbarColor = _create!(Tag.bossbarColor); + /// ditto + pragma(inline, true) bool isBossbarColor() const => _tag == Tag.bossbarColor; + ///ditto + alias getBossbarColor = _get!(Tag.bossbarColor); + + /++ + + +/ + alias bossbarStyle = _create!(Tag.bossbarStyle); + /// ditto + pragma(inline, true) bool isBossbarStyle() const => _tag == Tag.bossbarStyle; + ///ditto + alias getBossbarStyle = _get!(Tag.bossbarStyle); + + /++ + + +/ + alias soundCategory = _create!(Tag.soundCategory); + /// ditto + pragma(inline, true) bool isSoundCategory() const => _tag == Tag.soundCategory; + ///ditto + alias getSoundCategory = _get!(Tag.soundCategory); + + /++ + + +/ + alias damageType = _create!(Tag.damageType); + /// ditto + pragma(inline, true) bool isDamageType() const => _tag == Tag.damageType; + ///ditto + alias getDamageType = _get!(Tag.damageType); + + /++ + + +/ + alias effect = _create!(Tag.effect); + /// ditto + pragma(inline, true) bool isEffect() const => _tag == Tag.effect; + ///ditto + alias getEffect = _get!(Tag.effect); + + /++ + + +/ + alias enchantment = _create!(Tag.enchantment); + /// ditto + pragma(inline, true) bool isEnchantment() const => _tag == Tag.enchantment; + ///ditto + alias getEnchantment = _get!(Tag.enchantment); + + /++ + + +/ + alias advancement = _create!(Tag.advancement); + /// ditto + pragma(inline, true) bool isAdvancement() const => _tag == Tag.advancement; + ///ditto + alias getAdvancement = _get!(Tag.advancement); + + /++ + + +/ + alias entityAnchor = _create!(Tag.entityAnchor); + /// ditto + pragma(inline, true) bool isEntityAnchor() const => _tag == Tag.entityAnchor; + ///ditto + alias getEntityAnchor = _get!(Tag.entityAnchor); + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case simple: _get!(Tag.simple).witFree; break; + case msg: _get!(Tag.msg).witFree; break; + case item: _get!(Tag.item).witFree; break; + case itemPredicate: _get!(Tag.itemPredicate).witFree; break; + case resourceLocation: _get!(Tag.resourceLocation).witFree; break; + case block: _get!(Tag.block).witFree; break; + case blockPredicate: _get!(Tag.blockPredicate).witFree; break; + case players: _get!(Tag.players).witFree; break; + case particle: _get!(Tag.particle).witFree; break; + case damageType: _get!(Tag.damageType).witFree; break; + case effect: _get!(Tag.effect).witFree; break; + case enchantment: _get!(Tag.enchantment).witFree; break; + case advancement: _get!(Tag.advancement).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + switch (_tag) with (Tag) { + case players: _get!(Tag.players).witDrop; break; + case textComponent: _get!(Tag.textComponent).witDrop; break; + default: break; + } + } + + Arg witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.simple: return _create!(Tag.simple)(this._get!(Tag.simple).witClone); break; + case Tag.msg: return _create!(Tag.msg)(this._get!(Tag.msg).witClone); break; + case Tag.bool_: return _create!(Tag.bool_)(this._get!(Tag.bool_).witClone); break; + case Tag.item: return _create!(Tag.item)(this._get!(Tag.item).witClone); break; + case Tag.itemPredicate: return _create!(Tag.itemPredicate)(this._get!(Tag.itemPredicate).witClone); break; + case Tag.resourceLocation: return _create!(Tag.resourceLocation)(this._get!(Tag.resourceLocation).witClone); break; + case Tag.block: return _create!(Tag.block)(this._get!(Tag.block).witClone); break; + case Tag.blockPredicate: return _create!(Tag.blockPredicate)(this._get!(Tag.blockPredicate).witClone); break; + case Tag.time: return _create!(Tag.time)(this._get!(Tag.time).witClone); break; + case Tag.num: return _create!(Tag.num)(this._get!(Tag.num).witClone); break; + case Tag.blockPos: return _create!(Tag.blockPos)(this._get!(Tag.blockPos).witClone); break; + case Tag.pos3d: return _create!(Tag.pos3d)(this._get!(Tag.pos3d).witClone); break; + case Tag.pos2d: return _create!(Tag.pos2d)(this._get!(Tag.pos2d).witClone); break; + case Tag.rotation: return _create!(Tag.rotation)(this._get!(Tag.rotation).witClone); break; + case Tag.gamemode: return _create!(Tag.gamemode)(this._get!(Tag.gamemode).witClone); break; + case Tag.difficulty: return _create!(Tag.difficulty)(this._get!(Tag.difficulty).witClone); break; + case Tag.players: return _create!(Tag.players)(this._get!(Tag.players).witClone); break; + case Tag.particle: return _create!(Tag.particle)(this._get!(Tag.particle).witClone); break; + case Tag.textComponent: return _create!(Tag.textComponent)(this._get!(Tag.textComponent).witClone); break; + case Tag.bossbarColor: return _create!(Tag.bossbarColor)(this._get!(Tag.bossbarColor).witClone); break; + case Tag.bossbarStyle: return _create!(Tag.bossbarStyle)(this._get!(Tag.bossbarStyle).witClone); break; + case Tag.soundCategory: return _create!(Tag.soundCategory)(this._get!(Tag.soundCategory).witClone); break; + case Tag.damageType: return _create!(Tag.damageType)(this._get!(Tag.damageType).witClone); break; + case Tag.effect: return _create!(Tag.effect)(this._get!(Tag.effect).witClone); break; + case Tag.enchantment: return _create!(Tag.enchantment)(this._get!(Tag.enchantment).witClone); break; + case Tag.advancement: return _create!(Tag.advancement)(this._get!(Tag.advancement).witClone); break; + case Tag.entityAnchor: return _create!(Tag.entityAnchor)(this._get!(Tag.entityAnchor).witClone); break; + } + } +} + +/++ + ++/ +struct ConsumedArgs { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/command@0.1.0", "[resource-drop]consumed-args") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:resource_drop:consumed_args") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + Arg getValue(in WitString key) @trusted nothrow { + align(8) void[56] _retArea = void; + __import_getValue(this.__handle, cast(void*)(key.ptr), key.length, _retArea.ptr); + Arg _variant113 = void; + auto _tag113 = cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0))); + alias _Tag113 = Arg.Tag; + final switch (cast(Arg.Tag)_tag113) { + case _Tag113.simple: { + auto _len1 = *(cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof))); + auto _ptr1 = _len1 ? cast(char*)(*(cast(void**)(_retArea.ptr + 8))) : null; + auto _list2 = WitString(_ptr1[0.._len1]); + auto _payload114 = _list2; + _variant113 = Arg.simple(_payload114); + break; + } + case _Tag113.msg: { + auto _len4 = *(cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof))); + auto _ptr4 = _len4 ? cast(char*)(*(cast(void**)(_retArea.ptr + 8))) : null; + auto _list5 = WitString(_ptr4[0.._len4]); + auto _payload115 = _list5; + _variant113 = Arg.msg(_payload115); + break; + } + case _Tag113.bool_: { + auto _payload116 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 8)))) != 0; + _variant113 = Arg.bool_(_payload116); + break; + } + case _Tag113.item: { + auto _len8 = *(cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof))); + auto _ptr8 = _len8 ? cast(char*)(*(cast(void**)(_retArea.ptr + 8))) : null; + auto _list9 = WitString(_ptr8[0.._len8]); + auto _payload117 = _list9; + _variant113 = Arg.item(_payload117); + break; + } + case _Tag113.itemPredicate: { + auto _len11 = *(cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof))); + auto _ptr11 = _len11 ? cast(char*)(*(cast(void**)(_retArea.ptr + 8))) : null; + auto _list12 = WitString(_ptr11[0.._len11]); + auto _payload118 = _list12; + _variant113 = Arg.itemPredicate(_payload118); + break; + } + case _Tag113.resourceLocation: { + auto _len14 = *(cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof))); + auto _ptr14 = _len14 ? cast(char*)(*(cast(void**)(_retArea.ptr + 8))) : null; + auto _list15 = WitString(_ptr14[0.._len14]); + auto _payload119 = _list15; + _variant113 = Arg.resourceLocation(_payload119); + break; + } + case _Tag113.block: { + auto _len17 = *(cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof))); + auto _ptr17 = _len17 ? cast(char*)(*(cast(void**)(_retArea.ptr + 8))) : null; + auto _list18 = WitString(_ptr17[0.._len17]); + auto _payload120 = _list18; + _variant113 = Arg.block(_payload120); + break; + } + case _Tag113.blockPredicate: { + auto _len20 = *(cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof))); + auto _ptr20 = _len20 ? cast(char*)(*(cast(void**)(_retArea.ptr + 8))) : null; + auto _list21 = WitString(_ptr20[0.._len20]); + auto _payload121 = _list21; + _variant113 = Arg.blockPredicate(_payload121); + break; + } + case _Tag113.time: { + auto _payload122 = cast(int)(*(cast(uint*)(_retArea.ptr + 8))); + _variant113 = Arg.time(_payload122); + break; + } + case _Tag113.num: { + Result!(Number, NotInBounds) _result78 = void; + bool _isErr78 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 8)))) != 0; + if (_isErr78) { + NotInBounds _variant75 = void; + auto _tag75 = cast(uint)(*(cast(ubyte*)(_retArea.ptr + 16))); + alias _Tag75 = NotInBounds.Tag; + final switch (cast(NotInBounds.Tag)_tag75) { + case _Tag75.lowerBound: { + Number _variant40 = void; + auto _tag40 = cast(uint)(*(cast(ubyte*)(_retArea.ptr + 24))); + alias _Tag40 = Number.Tag; + final switch (cast(Number.Tag)_tag40) { + case _Tag40.float64: { + auto _payload41 = *(cast(double*)(_retArea.ptr + 32)); + _variant40 = Number.float64(_payload41); + break; + } + case _Tag40.float32: { + auto _payload42 = *(cast(float*)(_retArea.ptr + 32)); + _variant40 = Number.float32(_payload42); + break; + } + case _Tag40.int32: { + auto _payload43 = cast(int)(*(cast(uint*)(_retArea.ptr + 32))); + _variant40 = Number.int32(_payload43); + break; + } + case _Tag40.int64: { + auto _payload44 = cast(long)(*(cast(ulong*)(_retArea.ptr + 32))); + _variant40 = Number.int64(_payload44); + break; + } + } + Number _variant49 = void; + auto _tag49 = cast(uint)(*(cast(ubyte*)(_retArea.ptr + 40))); + alias _Tag49 = Number.Tag; + final switch (cast(Number.Tag)_tag49) { + case _Tag49.float64: { + auto _payload50 = *(cast(double*)(_retArea.ptr + 48)); + _variant49 = Number.float64(_payload50); + break; + } + case _Tag49.float32: { + auto _payload51 = *(cast(float*)(_retArea.ptr + 48)); + _variant49 = Number.float32(_payload51); + break; + } + case _Tag49.int32: { + auto _payload52 = cast(int)(*(cast(uint*)(_retArea.ptr + 48))); + _variant49 = Number.int32(_payload52); + break; + } + case _Tag49.int64: { + auto _payload53 = cast(long)(*(cast(ulong*)(_retArea.ptr + 48))); + _variant49 = Number.int64(_payload53); + break; + } + } + auto _tuple54 = Tuple!(Number, Number)( + _variant40, + _variant49, + ); + auto _payload76 = _tuple54; + _variant75 = NotInBounds.lowerBound(_payload76); + break; + } + case _Tag75.upperBound: { + Number _variant60 = void; + auto _tag60 = cast(uint)(*(cast(ubyte*)(_retArea.ptr + 24))); + alias _Tag60 = Number.Tag; + final switch (cast(Number.Tag)_tag60) { + case _Tag60.float64: { + auto _payload61 = *(cast(double*)(_retArea.ptr + 32)); + _variant60 = Number.float64(_payload61); + break; + } + case _Tag60.float32: { + auto _payload62 = *(cast(float*)(_retArea.ptr + 32)); + _variant60 = Number.float32(_payload62); + break; + } + case _Tag60.int32: { + auto _payload63 = cast(int)(*(cast(uint*)(_retArea.ptr + 32))); + _variant60 = Number.int32(_payload63); + break; + } + case _Tag60.int64: { + auto _payload64 = cast(long)(*(cast(ulong*)(_retArea.ptr + 32))); + _variant60 = Number.int64(_payload64); + break; + } + } + Number _variant69 = void; + auto _tag69 = cast(uint)(*(cast(ubyte*)(_retArea.ptr + 40))); + alias _Tag69 = Number.Tag; + final switch (cast(Number.Tag)_tag69) { + case _Tag69.float64: { + auto _payload70 = *(cast(double*)(_retArea.ptr + 48)); + _variant69 = Number.float64(_payload70); + break; + } + case _Tag69.float32: { + auto _payload71 = *(cast(float*)(_retArea.ptr + 48)); + _variant69 = Number.float32(_payload71); + break; + } + case _Tag69.int32: { + auto _payload72 = cast(int)(*(cast(uint*)(_retArea.ptr + 48))); + _variant69 = Number.int32(_payload72); + break; + } + case _Tag69.int64: { + auto _payload73 = cast(long)(*(cast(ulong*)(_retArea.ptr + 48))); + _variant69 = Number.int64(_payload73); + break; + } + } + auto _tuple74 = Tuple!(Number, Number)( + _variant60, + _variant69, + ); + auto _payload77 = _tuple74; + _variant75 = NotInBounds.upperBound(_payload77); + break; + } + } + + _result78 = Result!(Number, NotInBounds).makeErr(_variant75); + } else { + Number _variant29 = void; + auto _tag29 = cast(uint)(*(cast(ubyte*)(_retArea.ptr + 16))); + alias _Tag29 = Number.Tag; + final switch (cast(Number.Tag)_tag29) { + case _Tag29.float64: { + auto _payload30 = *(cast(double*)(_retArea.ptr + 24)); + _variant29 = Number.float64(_payload30); + break; + } + case _Tag29.float32: { + auto _payload31 = *(cast(float*)(_retArea.ptr + 24)); + _variant29 = Number.float32(_payload31); + break; + } + case _Tag29.int32: { + auto _payload32 = cast(int)(*(cast(uint*)(_retArea.ptr + 24))); + _variant29 = Number.int32(_payload32); + break; + } + case _Tag29.int64: { + auto _payload33 = cast(long)(*(cast(ulong*)(_retArea.ptr + 24))); + _variant29 = Number.int64(_payload33); + break; + } + } + + _result78 = Result!(Number, NotInBounds).makeOk(_variant29); + } + auto _payload123 = _result78; + _variant113 = Arg.num(_payload123); + break; + } + case _Tag113.blockPos: { + wit.pumpkin.plugin.common.imports.BlockPos _record80 = { + x: cast(int)(*(cast(uint*)(_retArea.ptr + 8))), + y: cast(int)(*(cast(uint*)(_retArea.ptr + 12))), + z: cast(int)(*(cast(uint*)(_retArea.ptr + 16))), + }; + auto _payload124 = _record80; + _variant113 = Arg.blockPos(_payload124); + break; + } + case _Tag113.pos3d: { + auto _tuple82 = Tuple!(double, double, double)( + *(cast(double*)(_retArea.ptr + 8)), + *(cast(double*)(_retArea.ptr + 16)), + *(cast(double*)(_retArea.ptr + 24)), + ); + auto _payload125 = _tuple82; + _variant113 = Arg.pos3d(_payload125); + break; + } + case _Tag113.pos2d: { + auto _tuple84 = Tuple!(double, double)( + *(cast(double*)(_retArea.ptr + 8)), + *(cast(double*)(_retArea.ptr + 16)), + ); + auto _payload126 = _tuple84; + _variant113 = Arg.pos2d(_payload126); + break; + } + case _Tag113.rotation: { + auto _tuple86 = Tuple!(float, bool, float, bool)( + *(cast(float*)(_retArea.ptr + 8)), + (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 12)))) != 0, + *(cast(float*)(_retArea.ptr + 16)), + (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 20)))) != 0, + ); + auto _payload127 = _tuple86; + _variant113 = Arg.rotation(_payload127); + break; + } + case _Tag113.gamemode: { + auto _payload128 = cast(wit.pumpkin.plugin.common.imports.GameMode)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 8)))); + _variant113 = Arg.gamemode(_payload128); + break; + } + case _Tag113.difficulty: { + auto _payload129 = cast(wit.pumpkin.plugin.server.imports.Difficulty)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 8)))); + _variant113 = Arg.difficulty(_payload129); + break; + } + case _Tag113.players: { + auto _len90 = *(cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof))); + auto _ptr90 = _len90 ? cast(Player*)(*(cast(void**)(_retArea.ptr + 8))) : null; + auto _list91 = WitList!(Player)(_ptr90[0.._len90]); + auto _payload130 = _list91; + _variant113 = Arg.players(_payload130); + break; + } + case _Tag113.particle: { + auto _len93 = *(cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof))); + auto _ptr93 = _len93 ? cast(char*)(*(cast(void**)(_retArea.ptr + 8))) : null; + auto _list94 = WitString(_ptr93[0.._len93]); + auto _payload131 = _list94; + _variant113 = Arg.particle(_payload131); + break; + } + case _Tag113.textComponent: { + auto _handle96 = TextComponent(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload132 = _handle96; + _variant113 = Arg.textComponent(_payload132); + break; + } + case _Tag113.bossbarColor: { + auto _payload133 = cast(BossbarColor)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 8)))); + _variant113 = Arg.bossbarColor(_payload133); + break; + } + case _Tag113.bossbarStyle: { + auto _payload134 = cast(BossbarStyle)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 8)))); + _variant113 = Arg.bossbarStyle(_payload134); + break; + } + case _Tag113.soundCategory: { + auto _payload135 = cast(SoundCategory)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 8)))); + _variant113 = Arg.soundCategory(_payload135); + break; + } + case _Tag113.damageType: { + auto _len101 = *(cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof))); + auto _ptr101 = _len101 ? cast(char*)(*(cast(void**)(_retArea.ptr + 8))) : null; + auto _list102 = WitString(_ptr101[0.._len101]); + auto _payload136 = _list102; + _variant113 = Arg.damageType(_payload136); + break; + } + case _Tag113.effect: { + auto _len104 = *(cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof))); + auto _ptr104 = _len104 ? cast(char*)(*(cast(void**)(_retArea.ptr + 8))) : null; + auto _list105 = WitString(_ptr104[0.._len104]); + auto _payload137 = _list105; + _variant113 = Arg.effect(_payload137); + break; + } + case _Tag113.enchantment: { + auto _len107 = *(cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof))); + auto _ptr107 = _len107 ? cast(char*)(*(cast(void**)(_retArea.ptr + 8))) : null; + auto _list108 = WitString(_ptr107[0.._len107]); + auto _payload138 = _list108; + _variant113 = Arg.enchantment(_payload138); + break; + } + case _Tag113.advancement: { + auto _len110 = *(cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof))); + auto _ptr110 = _len110 ? cast(char*)(*(cast(void**)(_retArea.ptr + 8))) : null; + auto _list111 = WitString(_ptr110[0.._len110]); + auto _payload139 = _list111; + _variant113 = Arg.advancement(_payload139); + break; + } + case _Tag113.entityAnchor: { + auto _payload140 = cast(EntityAnchor)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 8)))); + _variant113 = Arg.entityAnchor(_payload140); + break; + } + } + auto _flush141 = _variant113; + return _flush141; + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]consumed-args.get-value") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:consumed_args.get_value") + static private extern(C) void __import_getValue(uint, void*, size_t, void*) nothrow; + } +} + +/++ + ++/ +struct Command { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + /++ + First name is primary, rest are aliases + +/ + static Command makeNew(in WitList!(WitString) names, in WitString description) @trusted nothrow { + wit.common.DeallocateBuffer deallocate; + auto _listSrc1 = names; + auto _list1 = _listSrc1.length ? wit.common.malloc(_listSrc1.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc1.length || _list1); + if (_listSrc1.length) deallocate ~= _list1; + foreach (_elem0_idx, ref _elem0; _listSrc1) { + auto _base0 = _list1 + _elem0_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base0 + size_t.sizeof) = cast(size_t)(_elem0.length); + *cast(void**)(_base0 + 0) = cast(void*)(cast(void*)(_elem0.ptr)); + + } + auto _ret = __import_makeNew(_list1, names.length, cast(void*)(description.ptr), description.length); + deallocate.purge(); + auto _handle2 = Command(_ret); + return _handle2; + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[constructor]command") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:constructor:command") + static private extern(C) uint __import_makeNew(void*, size_t, void*, size_t) nothrow; + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/command@0.1.0", "[resource-drop]command") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:resource_drop:command") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + void then(CommandNode node) @trusted nothrow { + __import_then(this.__handle, node.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]command.then") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:command.then") + static private extern(C) void __import_then(uint, uint) nothrow; + + /++ + + +/ + void executeWithHandlerId(uint handlerId) @trusted nothrow { + __import_executeWithHandlerId(this.__handle, handlerId); + } + /// ditto + @wasmImport!("pumpkin:plugin/command@0.1.0", "[method]command.execute-with-handler-id") + pragma(mangle, "__wit_import_pumpkin:plugin__command@0.1.0__:method:command.execute_with_handler_id") + static private extern(C) void __import_executeWithHandlerId(uint, uint) nothrow; + } +} diff --git a/src/wit/pumpkin/plugin/common/common.d b/src/wit/pumpkin/plugin/common/common.d new file mode 100644 index 0000000..2fe23d8 --- /dev/null +++ b/src/wit/pumpkin/plugin/common/common.d @@ -0,0 +1,1324 @@ +/++ +Provides common types and utilities used across the entire plugin API. ++/ +module wit.pumpkin.plugin.common.common; + + +import wit.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ +Serialized text component as a postcard byte array. +@deprecated Use the text-component resource from the text interface instead. ++/ +alias RawTextComponent = WitList!(ubyte); +/++ +Represents one entry in an NBT compound tag. ++/ +struct NbtEntry { + /++ + + +/ + WitString key; + + /++ + + +/ + uint value; + + void witFree() @nogc nothrow { + key.witFree; + } + + void witDrop() @nogc nothrow { + } + + NbtEntry witClone() const @nogc nothrow { + NbtEntry clone = void; + clone.key = this.key.witClone; + clone.value = this.value.witClone; + return clone; + } +} + +/++ +Represents a Minecraft NBT tag. ++/ +struct NbtTag { + mixin WitVariant!( + byte, // byte_ + short, // short_ + int, // int_ + long, // long_ + float, // float_ + double, // double_ + WitList!(byte), // byteArray + WitString, // stringTag + WitList!(uint), // listTag + WitList!(NbtEntry), // compound + WitList!(int), // intArray + WitList!(long), // longArray + ); + +public: + enum Tag : ubyte { + /++ + + +/ + byte_, + + /++ + + +/ + short_, + + /++ + + +/ + int_, + + /++ + + +/ + long_, + + /++ + + +/ + float_, + + /++ + + +/ + double_, + + /++ + + +/ + byteArray, + + /++ + + +/ + stringTag, + + /++ + + +/ + listTag, + + /++ + + +/ + compound, + + /++ + + +/ + intArray, + + /++ + + +/ + longArray, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias byte_ = _create!(Tag.byte_); + /// ditto + pragma(inline, true) bool isByte() const => _tag == Tag.byte_; + ///ditto + alias getByte = _get!(Tag.byte_); + + /++ + + +/ + alias short_ = _create!(Tag.short_); + /// ditto + pragma(inline, true) bool isShort() const => _tag == Tag.short_; + ///ditto + alias getShort = _get!(Tag.short_); + + /++ + + +/ + alias int_ = _create!(Tag.int_); + /// ditto + pragma(inline, true) bool isInt() const => _tag == Tag.int_; + ///ditto + alias getInt = _get!(Tag.int_); + + /++ + + +/ + alias long_ = _create!(Tag.long_); + /// ditto + pragma(inline, true) bool isLong() const => _tag == Tag.long_; + ///ditto + alias getLong = _get!(Tag.long_); + + /++ + + +/ + alias float_ = _create!(Tag.float_); + /// ditto + pragma(inline, true) bool isFloat() const => _tag == Tag.float_; + ///ditto + alias getFloat = _get!(Tag.float_); + + /++ + + +/ + alias double_ = _create!(Tag.double_); + /// ditto + pragma(inline, true) bool isDouble() const => _tag == Tag.double_; + ///ditto + alias getDouble = _get!(Tag.double_); + + /++ + + +/ + alias byteArray = _create!(Tag.byteArray); + /// ditto + pragma(inline, true) bool isByteArray() const => _tag == Tag.byteArray; + ///ditto + alias getByteArray = _get!(Tag.byteArray); + + /++ + + +/ + alias stringTag = _create!(Tag.stringTag); + /// ditto + pragma(inline, true) bool isStringTag() const => _tag == Tag.stringTag; + ///ditto + alias getStringTag = _get!(Tag.stringTag); + + /++ + + +/ + alias listTag = _create!(Tag.listTag); + /// ditto + pragma(inline, true) bool isListTag() const => _tag == Tag.listTag; + ///ditto + alias getListTag = _get!(Tag.listTag); + + /++ + + +/ + alias compound = _create!(Tag.compound); + /// ditto + pragma(inline, true) bool isCompound() const => _tag == Tag.compound; + ///ditto + alias getCompound = _get!(Tag.compound); + + /++ + + +/ + alias intArray = _create!(Tag.intArray); + /// ditto + pragma(inline, true) bool isIntArray() const => _tag == Tag.intArray; + ///ditto + alias getIntArray = _get!(Tag.intArray); + + /++ + + +/ + alias longArray = _create!(Tag.longArray); + /// ditto + pragma(inline, true) bool isLongArray() const => _tag == Tag.longArray; + ///ditto + alias getLongArray = _get!(Tag.longArray); + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case byteArray: _get!(Tag.byteArray).witFree; break; + case stringTag: _get!(Tag.stringTag).witFree; break; + case listTag: _get!(Tag.listTag).witFree; break; + case compound: _get!(Tag.compound).witFree; break; + case intArray: _get!(Tag.intArray).witFree; break; + case longArray: _get!(Tag.longArray).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + } + + NbtTag witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.byte_: return _create!(Tag.byte_)(this._get!(Tag.byte_).witClone); break; + case Tag.short_: return _create!(Tag.short_)(this._get!(Tag.short_).witClone); break; + case Tag.int_: return _create!(Tag.int_)(this._get!(Tag.int_).witClone); break; + case Tag.long_: return _create!(Tag.long_)(this._get!(Tag.long_).witClone); break; + case Tag.float_: return _create!(Tag.float_)(this._get!(Tag.float_).witClone); break; + case Tag.double_: return _create!(Tag.double_)(this._get!(Tag.double_).witClone); break; + case Tag.byteArray: return _create!(Tag.byteArray)(this._get!(Tag.byteArray).witClone); break; + case Tag.stringTag: return _create!(Tag.stringTag)(this._get!(Tag.stringTag).witClone); break; + case Tag.listTag: return _create!(Tag.listTag)(this._get!(Tag.listTag).witClone); break; + case Tag.compound: return _create!(Tag.compound)(this._get!(Tag.compound).witClone); break; + case Tag.intArray: return _create!(Tag.intArray)(this._get!(Tag.intArray).witClone); break; + case Tag.longArray: return _create!(Tag.longArray)(this._get!(Tag.longArray).witClone); break; + } + } +} + +/++ +Represents a Minecraft NBT tag tree. ++/ +struct NbtTree { + /++ + + +/ + uint root; + + /++ + + +/ + WitList!(NbtTag) tags; + + void witFree() @nogc nothrow { + tags.witFree; + } + + void witDrop() @nogc nothrow { + } + + NbtTree witClone() const @nogc nothrow { + NbtTree clone = void; + clone.root = this.root.witClone; + clone.tags = this.tags.witClone; + return clone; + } +} + +/++ +A position in the world grid (integers). ++/ +struct BlockPos { + /++ + + +/ + int x; + + /++ + + +/ + int y; + + /++ + + +/ + int z; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + BlockPos witClone() const @nogc nothrow { + BlockPos clone = void; + clone.x = this.x.witClone; + clone.y = this.y.witClone; + clone.z = this.z.witClone; + return clone; + } +} + +/++ +A precise coordinate in the world (floats). ++/ +alias Position = Tuple!(double, double, double); +/++ +Represents the hands of a player. ++/ +enum Hand : ubyte { + /++ + + +/ + left, + + /++ + + +/ + right, +} +/++ +Represents the game modes available in Minecraft. ++/ +enum GameMode : ubyte { + /++ + + +/ + survival, + + /++ + + +/ + creative, + + /++ + + +/ + adventure, + + /++ + + +/ + spectator, +} +/++ +The 16 base Minecraft colors. ++/ +enum NamedColor : ubyte { + /++ + + +/ + black, + + /++ + + +/ + darkBlue, + + /++ + + +/ + darkGreen, + + /++ + + +/ + darkAqua, + + /++ + + +/ + darkRed, + + /++ + + +/ + darkPurple, + + /++ + + +/ + gold, + + /++ + + +/ + gray, + + /++ + + +/ + darkGray, + + /++ + + +/ + blue, + + /++ + + +/ + green, + + /++ + + +/ + aqua, + + /++ + + +/ + red, + + /++ + + +/ + lightPurple, + + /++ + + +/ + yellow, + + /++ + + +/ + white, +} +/++ +An RGB color represented by its red, green, and blue components. ++/ +struct RgbColor { + /++ + + +/ + ubyte r; + + /++ + + +/ + ubyte g; + + /++ + + +/ + ubyte b; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + RgbColor witClone() const @nogc nothrow { + RgbColor clone = void; + clone.r = this.r.witClone; + clone.g = this.g.witClone; + clone.b = this.b.witClone; + return clone; + } +} + +/++ +An ARGB color with alpha (transparency) channel. ++/ +struct ArgbColor { + /++ + + +/ + ubyte a; + + /++ + + +/ + ubyte r; + + /++ + + +/ + ubyte g; + + /++ + + +/ + ubyte b; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ArgbColor witClone() const @nogc nothrow { + ArgbColor clone = void; + clone.a = this.a.witClone; + clone.r = this.r.witClone; + clone.g = this.g.witClone; + clone.b = this.b.witClone; + return clone; + } +} + +/++ +Represents the type of click interaction in a GUI. ++/ +enum ClickType : ubyte { + /++ + + +/ + left, + + /++ + + +/ + right, + + /++ + + +/ + shiftLeft, + + /++ + + +/ + shiftRight, + + /++ + + +/ + middle, + + /++ + + +/ + drop, + + /++ + + +/ + controlDrop, + + /++ + + +/ + doubleClick, + + /++ + + +/ + numberKey, + + /++ + + +/ + unknown, +} +/++ +Represents the various poses an entity can be in. ++/ +enum EntityPose : ubyte { + /++ + + +/ + standing, + + /++ + + +/ + fallFlying, + + /++ + + +/ + sleeping, + + /++ + + +/ + swimming, + + /++ + + +/ + spinAttack, + + /++ + + +/ + crouching, + + /++ + + +/ + longJumping, + + /++ + + +/ + dying, + + /++ + + +/ + croaking, + + /++ + + +/ + usingTongue, + + /++ + + +/ + sitting, + + /++ + + +/ + roaring, + + /++ + + +/ + sniffing, + + /++ + + +/ + emerging, + + /++ + + +/ + digging, + + /++ + + +/ + sliding, + + /++ + + +/ + shooting, + + /++ + + +/ + inhaling, +} +/++ +All Minecraft-supported locales. ++/ +enum Locale : ubyte { + /++ + + +/ + afZa, + + /++ + + +/ + arSa, + + /++ + + +/ + astEs, + + /++ + + +/ + azAz, + + /++ + + +/ + baRu, + + /++ + + +/ + bar, + + /++ + + +/ + beBy, + + /++ + + +/ + bgBg, + + /++ + + +/ + brFr, + + /++ + + +/ + brb, + + /++ + + +/ + bsBa, + + /++ + + +/ + caEs, + + /++ + + +/ + csCz, + + /++ + + +/ + cyGb, + + /++ + + +/ + daDk, + + /++ + + +/ + deAt, + + /++ + + +/ + deCh, + + /++ + + +/ + deDe, + + /++ + + +/ + elGr, + + /++ + + +/ + enAu, + + /++ + + +/ + enCa, + + /++ + + +/ + enGb, + + /++ + + +/ + enNz, + + /++ + + +/ + enPt, + + /++ + + +/ + enUd, + + /++ + + +/ + enUs, + + /++ + + +/ + enp, + + /++ + + +/ + enws, + + /++ + + +/ + eoUy, + + /++ + + +/ + esAr, + + /++ + + +/ + esCl, + + /++ + + +/ + esEc, + + /++ + + +/ + esEs, + + /++ + + +/ + esMx, + + /++ + + +/ + esUy, + + /++ + + +/ + esVe, + + /++ + + +/ + esan, + + /++ + + +/ + etEe, + + /++ + + +/ + euEs, + + /++ + + +/ + faIr, + + /++ + + +/ + fiFi, + + /++ + + +/ + filPh, + + /++ + + +/ + foFo, + + /++ + + +/ + frCa, + + /++ + + +/ + frFr, + + /++ + + +/ + fraDe, + + /++ + + +/ + furIt, + + /++ + + +/ + fyNl, + + /++ + + +/ + gaIe, + + /++ + + +/ + gdGb, + + /++ + + +/ + glEs, + + /++ + + +/ + hawUs, + + /++ + + +/ + heIl, + + /++ + + +/ + hiIn, + + /++ + + +/ + hrHr, + + /++ + + +/ + huHu, + + /++ + + +/ + hyAm, + + /++ + + +/ + idId, + + /++ + + +/ + igNg, + + /++ + + +/ + ioEn, + + /++ + + +/ + isIs, + + /++ + + +/ + isv, + + /++ + + +/ + itIt, + + /++ + + +/ + jaJp, + + /++ + + +/ + jboEn, + + /++ + + +/ + kaGe, + + /++ + + +/ + kkKz, + + /++ + + +/ + knIn, + + /++ + + +/ + koKr, + + /++ + + +/ + ksh, + + /++ + + +/ + kwGb, + + /++ + + +/ + laLa, + + /++ + + +/ + lbLu, + + /++ + + +/ + liLi, + + /++ + + +/ + lmo, + + /++ + + +/ + loLa, + + /++ + + +/ + lolUs, + + /++ + + +/ + ltLt, + + /++ + + +/ + lvLv, + + /++ + + +/ + lzh, + + /++ + + +/ + mkMk, + + /++ + + +/ + mnMn, + + /++ + + +/ + msMy, + + /++ + + +/ + mtMt, + + /++ + + +/ + nah, + + /++ + + +/ + ndsDe, + + /++ + + +/ + nlBe, + + /++ + + +/ + nlNl, + + /++ + + +/ + nnNo, + + /++ + + +/ + noNo, + + /++ + + +/ + ocFr, + + /++ + + +/ + ovd, + + /++ + + +/ + plPl, + + /++ + + +/ + ptBr, + + /++ + + +/ + ptPt, + + /++ + + +/ + qyaAa, + + /++ + + +/ + roRo, + + /++ + + +/ + rpr, + + /++ + + +/ + ruRu, + + /++ + + +/ + ryUa, + + /++ + + +/ + sahSah, + + /++ + + +/ + seNo, + + /++ + + +/ + skSk, + + /++ + + +/ + slSi, + + /++ + + +/ + soSo, + + /++ + + +/ + sqAl, + + /++ + + +/ + srCs, + + /++ + + +/ + srSp, + + /++ + + +/ + svSe, + + /++ + + +/ + sxu, + + /++ + + +/ + szl, + + /++ + + +/ + taIn, + + /++ + + +/ + thTh, + + /++ + + +/ + tlPh, + + /++ + + +/ + tlhAa, + + /++ + + +/ + tok, + + /++ + + +/ + trTr, + + /++ + + +/ + ttRu, + + /++ + + +/ + ukUa, + + /++ + + +/ + valEs, + + /++ + + +/ + vecIt, + + /++ + + +/ + viVn, + + /++ + + +/ + yiDe, + + /++ + + +/ + yoNg, + + /++ + + +/ + zhCn, + + /++ + + +/ + zhHk, + + /++ + + +/ + zhTw, + + /++ + + +/ + zlmArab, +} \ No newline at end of file diff --git a/src/wit/pumpkin/plugin/common/imports.d b/src/wit/pumpkin/plugin/common/imports.d new file mode 100644 index 0000000..c298f58 --- /dev/null +++ b/src/wit/pumpkin/plugin/common/imports.d @@ -0,0 +1,12 @@ +/++ +Provides common types and utilities used across the entire plugin API. ++/ +module wit.pumpkin.plugin.common.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.common.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); diff --git a/src/wit/pumpkin/plugin/context/common.d b/src/wit/pumpkin/plugin/context/common.d new file mode 100644 index 0000000..c0c5789 --- /dev/null +++ b/src/wit/pumpkin/plugin/context/common.d @@ -0,0 +1,111 @@ +/++ +The core context provided to a plugin during initialization and event handling. ++/ +module wit.pumpkin.plugin.context.common; + + +import wit.common; + +static import wit.pumpkin.plugin.permission.common; +static import wit.pumpkin.plugin.event.common; +static import wit.pumpkin.plugin.server.common; +static import wit.pumpkin.plugin.command.common; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias EventType = wit.pumpkin.plugin.event.common.EventType; + +/++ + ++/ +alias EventPriority = wit.pumpkin.plugin.event.common.EventPriority; + +/++ + ++/ +alias Permission = wit.pumpkin.plugin.permission.common.Permission; + +/++ +Verified marketplace metadata for signed plugins. ++/ +struct MarketplaceMetadata { + /++ + The marketplace base URL where this plugin is registered. + +/ + WitString marketplaceUrl; + + /++ + The unique plugin ID on the marketplace. + +/ + long pluginId; + + /++ + The canonical plugin name. + +/ + WitString pluginName; + + /++ + The semver version string of the plugin. + +/ + WitString version_; + + /++ + Developer ID. + +/ + long devId; + + /++ + Developer display name or username. + +/ + WitString devName; + + /++ + Whether this is a paid marketplace plugin. + +/ + bool isPaid; + + /++ + The buyer / licensee user ID (0 for free/open-source). + +/ + long userId; + + /++ + Unique license key issued to the buyer, if paid. + +/ + Option!(WitString) licenseKey; + + /++ + ISO-8601 timestamp of when this binary/license was issued. + +/ + WitString issuedAt; + + void witFree() @nogc nothrow { + marketplaceUrl.witFree; + pluginName.witFree; + version_.witFree; + devName.witFree; + licenseKey.witFree; + issuedAt.witFree; + } + + void witDrop() @nogc nothrow { + } + + MarketplaceMetadata witClone() const @nogc nothrow { + MarketplaceMetadata clone = void; + clone.marketplaceUrl = this.marketplaceUrl.witClone; + clone.pluginId = this.pluginId.witClone; + clone.pluginName = this.pluginName.witClone; + clone.version_ = this.version_.witClone; + clone.devId = this.devId.witClone; + clone.devName = this.devName.witClone; + clone.isPaid = this.isPaid.witClone; + clone.userId = this.userId.witClone; + clone.licenseKey = this.licenseKey.witClone; + clone.issuedAt = this.issuedAt.witClone; + return clone; + } +} diff --git a/src/wit/pumpkin/plugin/context/imports.d b/src/wit/pumpkin/plugin/context/imports.d new file mode 100644 index 0000000..14481f0 --- /dev/null +++ b/src/wit/pumpkin/plugin/context/imports.d @@ -0,0 +1,249 @@ +/++ +The core context provided to a plugin during initialization and event handling. ++/ +module wit.pumpkin.plugin.context.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.context.common; + +static import wit.pumpkin.plugin.permission.imports; +static import wit.pumpkin.plugin.event.imports; +static import wit.pumpkin.plugin.server.imports; +static import wit.pumpkin.plugin.command.imports; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias Server = wit.pumpkin.plugin.server.imports.Server; + +/++ + ++/ +alias Command = wit.pumpkin.plugin.command.imports.Command; + +/++ +A contextual handle for plugin-related operations. ++/ +struct Context { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/context@0.1.0", "[resource-drop]context") + pragma(mangle, "__wit_import_pumpkin:plugin__context@0.1.0__:resource_drop:context") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + Registers a handler for a specific event. + + * `handler-id`: Unique ID for the event handler. + * `event-type`: The type of event to listen for. + * `event-priority`: When this handler should be called relative to others. + * `blocking`: Whether the event should wait for this handler to finish. + +/ + void registerEvent(uint handlerId, EventType eventType, EventPriority eventPriority, bool blocking) @trusted nothrow { + __import_registerEvent(this.__handle, handlerId, cast(uint)(eventType), cast(uint)(eventPriority), cast(uint)(blocking)); + } + /// ditto + @wasmImport!("pumpkin:plugin/context@0.1.0", "[method]context.register-event") + pragma(mangle, "__wit_import_pumpkin:plugin__context@0.1.0__:method:context.register_event") + static private extern(C) void __import_registerEvent(uint, uint, uint, uint, uint) nothrow; + + /++ + Registers a new command. + + * `command`: The command definition. + * `permission`: The required permission node to execute this command. + +/ + void registerCommand(Command command, in WitString permission) @trusted nothrow { + __import_registerCommand(this.__handle, command.__handle, cast(void*)(permission.ptr), permission.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/context@0.1.0", "[method]context.register-command") + pragma(mangle, "__wit_import_pumpkin:plugin__context@0.1.0__:method:context.register_command") + static private extern(C) void __import_registerCommand(uint, uint, void*, size_t) nothrow; + + /++ + Registers a permission node with the server. + +/ + Result!(void, WitString) registerPermission(in Permission permission) @trusted nothrow { + align(size_t.sizeof) void[(3*size_t.sizeof)] _retArea = void; + wit.common.DeallocateBuffer deallocate; + uint _variantPart6 = void; + uint _variantPart7 = void; + alias _Tag8 = wit.pumpkin.plugin.permission.imports.PermissionDefault.Tag; + final switch (permission.default_.tag) { + case _Tag8.deny: { + _variantPart6 = 0; + _variantPart7 = 0; + break; + } + case _Tag8.allow: { + _variantPart6 = 1; + _variantPart7 = 0; + break; + } + case _Tag8.op: { + const ref wit.pumpkin.plugin.permission.imports.PermissionLevel _payload5 = permission.default_.getOp(); + _variantPart6 = 2; + _variantPart7 = cast(uint)(_payload5); + break; + } + } + auto _listSrc10 = permission.children; + auto _list10 = _listSrc10.length ? wit.common.malloc(_listSrc10.length * ((3*size_t.sizeof))) : null; + assert(!_listSrc10.length || _list10); + if (_listSrc10.length) deallocate ~= _list10; + foreach (_elem9_idx, ref _elem9; _listSrc10) { + auto _base9 = _list10 + _elem9_idx * ((3*size_t.sizeof)); + *cast(size_t*)(_base9 + size_t.sizeof) = cast(size_t)(_elem9.node.length); + *cast(void**)(_base9 + 0) = cast(void*)(cast(void*)(_elem9.node.ptr)); + *cast(ubyte*)(_base9 + (2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem9.value)); + + } + __import_registerPermission(this.__handle, cast(void*)(permission.node.ptr), permission.node.length, cast(void*)(permission.description.ptr), permission.description.length, _variantPart6, _variantPart7, _list10, permission.children.length, _retArea.ptr); + deallocate.purge(); + Result!(void, WitString) _result15 = void; + bool _isErr15 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isErr15) { + auto _len13 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr13 = _len13 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list14 = WitString(_ptr13[0.._len13]); + + _result15 = Result!(void, WitString).makeErr(_list14); + } else { + + _result15 = Result!(void, WitString).makeOk(); + } + auto _flush16 = _result15; + return _flush16; + } + /// ditto + @wasmImport!("pumpkin:plugin/context@0.1.0", "[method]context.register-permission") + pragma(mangle, "__wit_import_pumpkin:plugin__context@0.1.0__:method:context.register_permission") + static private extern(C) void __import_registerPermission(uint, void*, size_t, void*, size_t, uint, uint, void*, size_t, void*) nothrow; + + /++ + Returns the path to the plugin's private data folder. + +/ + WitString getDataFolder() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getDataFolder(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/context@0.1.0", "[method]context.get-data-folder") + pragma(mangle, "__wit_import_pumpkin:plugin__context@0.1.0__:method:context.get_data_folder") + static private extern(C) void __import_getDataFolder(uint, void*) nothrow; + + /++ + Returns the global server instance. + +/ + Server getServer() @trusted nothrow { + auto _ret = __import_getServer(this.__handle); + auto _handle0 = Server(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/context@0.1.0", "[method]context.get-server") + pragma(mangle, "__wit_import_pumpkin:plugin__context@0.1.0__:method:context.get_server") + static private extern(C) uint __import_getServer(uint) nothrow; + + /++ + Returns verified marketplace metadata if this plugin binary is signed, or none if unsigned. + +/ + Option!(MarketplaceMetadata) getMarketplaceMetadata() @trusted nothrow { + align(8) void[(48+12*size_t.sizeof)] _retArea = void; + __import_getMarketplaceMetadata(this.__handle, _retArea.ptr); + Option!(MarketplaceMetadata) _option18 = void; + bool _isSome18 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome18) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + 8))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + auto _len4 = *(cast(size_t*)(_retArea.ptr + (16+3*size_t.sizeof))); + auto _ptr4 = _len4 ? cast(char*)(*(cast(void**)(_retArea.ptr + (16+2*size_t.sizeof)))) : null; + auto _list5 = WitString(_ptr4[0.._len4]); + auto _len6 = *(cast(size_t*)(_retArea.ptr + (16+5*size_t.sizeof))); + auto _ptr6 = _len6 ? cast(char*)(*(cast(void**)(_retArea.ptr + (16+4*size_t.sizeof)))) : null; + auto _list7 = WitString(_ptr6[0.._len6]); + auto _len8 = *(cast(size_t*)(_retArea.ptr + (24+7*size_t.sizeof))); + auto _ptr8 = _len8 ? cast(char*)(*(cast(void**)(_retArea.ptr + (24+6*size_t.sizeof)))) : null; + auto _list9 = WitString(_ptr8[0.._len8]); + Option!(WitString) _option14 = void; + bool _isSome14 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (40+8*size_t.sizeof))))) != 0; + if (_isSome14) { + auto _len12 = *(cast(size_t*)(_retArea.ptr + (40+10*size_t.sizeof))); + auto _ptr12 = _len12 ? cast(char*)(*(cast(void**)(_retArea.ptr + (40+9*size_t.sizeof)))) : null; + auto _list13 = WitString(_ptr12[0.._len12]); + + _option14 = Option!(WitString).makeSome(_list13); + } else { + _option14 = Option!(WitString).makeNone; + } + auto _len15 = *(cast(size_t*)(_retArea.ptr + (40+12*size_t.sizeof))); + auto _ptr15 = _len15 ? cast(char*)(*(cast(void**)(_retArea.ptr + (40+11*size_t.sizeof)))) : null; + auto _list16 = WitString(_ptr15[0.._len15]); + MarketplaceMetadata _record17 = { + marketplaceUrl: _list3, + pluginId: cast(long)(*(cast(ulong*)(_retArea.ptr + (8+2*size_t.sizeof)))), + pluginName: _list5, + version_: _list7, + devId: cast(long)(*(cast(ulong*)(_retArea.ptr + (16+6*size_t.sizeof)))), + devName: _list9, + isPaid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (24+8*size_t.sizeof))))) != 0, + userId: cast(long)(*(cast(ulong*)(_retArea.ptr + (32+8*size_t.sizeof)))), + licenseKey: _option14, + issuedAt: _list16, + }; + + _option18 = Option!(MarketplaceMetadata).makeSome(_record17); + } else { + _option18 = Option!(MarketplaceMetadata).makeNone; + } + auto _flush19 = _option18; + return _flush19; + } + /// ditto + @wasmImport!("pumpkin:plugin/context@0.1.0", "[method]context.get-marketplace-metadata") + pragma(mangle, "__wit_import_pumpkin:plugin__context@0.1.0__:method:context.get_marketplace_metadata") + static private extern(C) void __import_getMarketplaceMetadata(uint, void*) nothrow; + } +} diff --git a/src/wit/pumpkin/plugin/damage_types/common.d b/src/wit/pumpkin/plugin/damage_types/common.d new file mode 100644 index 0000000..2b1738b --- /dev/null +++ b/src/wit/pumpkin/plugin/damage_types/common.d @@ -0,0 +1,270 @@ +/++ + ++/ +module wit.pumpkin.plugin.damage_types.common; + + +import wit.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +enum DamageType : ubyte { + /++ + + +/ + arrow, + + /++ + + +/ + badRespawnPoint, + + /++ + + +/ + cactus, + + /++ + + +/ + campfire, + + /++ + + +/ + cramming, + + /++ + + +/ + dragonBreath, + + /++ + + +/ + drown, + + /++ + + +/ + dryOut, + + /++ + + +/ + enderPearl, + + /++ + + +/ + explosion, + + /++ + + +/ + fall, + + /++ + + +/ + fallingAnvil, + + /++ + + +/ + fallingBlock, + + /++ + + +/ + fallingStalactite, + + /++ + + +/ + fireball, + + /++ + + +/ + fireworks, + + /++ + + +/ + flyIntoWall, + + /++ + + +/ + freeze, + + /++ + + +/ + generic, + + /++ + + +/ + genericKill, + + /++ + + +/ + hotFloor, + + /++ + + +/ + inFire, + + /++ + + +/ + inWall, + + /++ + + +/ + indirectMagic, + + /++ + + +/ + lava, + + /++ + + +/ + lightningBolt, + + /++ + + +/ + maceSmash, + + /++ + + +/ + magic, + + /++ + + +/ + mobAttack, + + /++ + + +/ + mobAttackNoAggro, + + /++ + + +/ + mobProjectile, + + /++ + + +/ + onFire, + + /++ + + +/ + outOfWorld, + + /++ + + +/ + outsideBorder, + + /++ + + +/ + playerAttack, + + /++ + + +/ + playerExplosion, + + /++ + + +/ + sonicBoom, + + /++ + + +/ + spear, + + /++ + + +/ + spit, + + /++ + + +/ + stalagmite, + + /++ + + +/ + starve, + + /++ + + +/ + sting, + + /++ + + +/ + sulfurCubeHot, + + /++ + + +/ + sweetBerryBush, + + /++ + + +/ + thorns, + + /++ + + +/ + thrown, + + /++ + + +/ + trident, + + /++ + + +/ + unattributedFireball, + + /++ + + +/ + windCharge, + + /++ + + +/ + wither, + + /++ + + +/ + witherSkull, +} \ No newline at end of file diff --git a/src/wit/pumpkin/plugin/damage_types/imports.d b/src/wit/pumpkin/plugin/damage_types/imports.d new file mode 100644 index 0000000..e069688 --- /dev/null +++ b/src/wit/pumpkin/plugin/damage_types/imports.d @@ -0,0 +1,12 @@ +/++ + ++/ +module wit.pumpkin.plugin.damage_types.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.damage_types.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); diff --git a/src/wit/pumpkin/plugin/data_components/common.d b/src/wit/pumpkin/plugin/data_components/common.d new file mode 100644 index 0000000..cabd8fa --- /dev/null +++ b/src/wit/pumpkin/plugin/data_components/common.d @@ -0,0 +1,570 @@ +/++ + ++/ +module wit.pumpkin.plugin.data_components.common; + + +import wit.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +enum DataComponent : ubyte { + /++ + + +/ + customData, + + /++ + + +/ + maxStackSize, + + /++ + + +/ + maxDamage, + + /++ + + +/ + damage, + + /++ + + +/ + unbreakable, + + /++ + + +/ + useEffects, + + /++ + + +/ + customName, + + /++ + + +/ + minimumAttackCharge, + + /++ + + +/ + damageType, + + /++ + + +/ + itemName, + + /++ + + +/ + itemModel, + + /++ + + +/ + lore, + + /++ + + +/ + rarity, + + /++ + + +/ + enchantments, + + /++ + + +/ + canPlaceOn, + + /++ + + +/ + canBreak, + + /++ + + +/ + attributeModifiers, + + /++ + + +/ + customModelData, + + /++ + + +/ + tooltipDisplay, + + /++ + + +/ + repairCost, + + /++ + + +/ + creativeSlotLock, + + /++ + + +/ + enchantmentGlintOverride, + + /++ + + +/ + intangibleProjectile, + + /++ + + +/ + food, + + /++ + + +/ + consumable, + + /++ + + +/ + useRemainder, + + /++ + + +/ + useCooldown, + + /++ + + +/ + damageResistant, + + /++ + + +/ + tool, + + /++ + + +/ + weapon, + + /++ + + +/ + attackRange, + + /++ + + +/ + enchantable, + + /++ + + +/ + equippable, + + /++ + + +/ + repairable, + + /++ + + +/ + glider, + + /++ + + +/ + tooltipStyle, + + /++ + + +/ + deathProtection, + + /++ + + +/ + blocksAttacks, + + /++ + + +/ + piercingWeapon, + + /++ + + +/ + kineticWeapon, + + /++ + + +/ + swingAnimation, + + /++ + + +/ + additionalTradeCost, + + /++ + + +/ + storedEnchantments, + + /++ + + +/ + dye, + + /++ + + +/ + dyedColor, + + /++ + + +/ + mapColor, + + /++ + + +/ + mapId, + + /++ + + +/ + mapDecorations, + + /++ + + +/ + mapPostProcessing, + + /++ + + +/ + chargedProjectiles, + + /++ + + +/ + bundleContents, + + /++ + + +/ + potionContents, + + /++ + + +/ + potionDurationScale, + + /++ + + +/ + suspiciousStewEffects, + + /++ + + +/ + writableBookContent, + + /++ + + +/ + writtenBookContent, + + /++ + + +/ + trim, + + /++ + + +/ + debugStickState, + + /++ + + +/ + entityData, + + /++ + + +/ + bucketEntityData, + + /++ + + +/ + blockEntityData, + + /++ + + +/ + instrument, + + /++ + + +/ + providesTrimMaterial, + + /++ + + +/ + ominousBottleAmplifier, + + /++ + + +/ + jukeboxPlayable, + + /++ + + +/ + providesBannerPatterns, + + /++ + + +/ + recipes, + + /++ + + +/ + lodestoneTracker, + + /++ + + +/ + fireworkExplosion, + + /++ + + +/ + fireworks, + + /++ + + +/ + profile, + + /++ + + +/ + noteBlockSound, + + /++ + + +/ + bannerPatterns, + + /++ + + +/ + baseColor, + + /++ + + +/ + potDecorations, + + /++ + + +/ + container, + + /++ + + +/ + blockState, + + /++ + + +/ + bees, + + /++ + + +/ + sulfurCubeContent, + + /++ + + +/ + lock, + + /++ + + +/ + containerLoot, + + /++ + + +/ + breakSound, + + /++ + + +/ + villagerVariant, + + /++ + + +/ + wolfVariant, + + /++ + + +/ + wolfSoundVariant, + + /++ + + +/ + wolfCollar, + + /++ + + +/ + foxVariant, + + /++ + + +/ + salmonSize, + + /++ + + +/ + parrotVariant, + + /++ + + +/ + tropicalFishPattern, + + /++ + + +/ + tropicalFishBaseColor, + + /++ + + +/ + tropicalFishPatternColor, + + /++ + + +/ + mooshroomVariant, + + /++ + + +/ + rabbitVariant, + + /++ + + +/ + pigVariant, + + /++ + + +/ + pigSoundVariant, + + /++ + + +/ + cowVariant, + + /++ + + +/ + cowSoundVariant, + + /++ + + +/ + chickenVariant, + + /++ + + +/ + chickenSoundVariant, + + /++ + + +/ + zombieNautilusVariant, + + /++ + + +/ + frogVariant, + + /++ + + +/ + horseVariant, + + /++ + + +/ + paintingVariant, + + /++ + + +/ + llamaVariant, + + /++ + + +/ + axolotlVariant, + + /++ + + +/ + catVariant, + + /++ + + +/ + catSoundVariant, + + /++ + + +/ + catCollar, + + /++ + + +/ + sheepColor, + + /++ + + +/ + shulkerColor, +} \ No newline at end of file diff --git a/src/wit/pumpkin/plugin/data_components/imports.d b/src/wit/pumpkin/plugin/data_components/imports.d new file mode 100644 index 0000000..2cce9b9 --- /dev/null +++ b/src/wit/pumpkin/plugin/data_components/imports.d @@ -0,0 +1,12 @@ +/++ + ++/ +module wit.pumpkin.plugin.data_components.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.data_components.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); diff --git a/src/wit/pumpkin/plugin/datapack/common.d b/src/wit/pumpkin/plugin/datapack/common.d new file mode 100644 index 0000000..1a2a139 --- /dev/null +++ b/src/wit/pumpkin/plugin/datapack/common.d @@ -0,0 +1,159 @@ +/++ + ++/ +module wit.pumpkin.plugin.datapack.common; + + +import wit.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ +Information about a discovered or loaded datapack. ++/ +struct DatapackInfo { + /++ + + +/ + WitString id; + + /++ + + +/ + WitString name; + + /++ + + +/ + WitString description; + + /++ + + +/ + uint packFormat; + + /++ + + +/ + bool isEnabled; + + /++ + + +/ + uint recipeCount; + + /++ + + +/ + uint functionCount; + + void witFree() @nogc nothrow { + id.witFree; + name.witFree; + description.witFree; + } + + void witDrop() @nogc nothrow { + } + + DatapackInfo witClone() const @nogc nothrow { + DatapackInfo clone = void; + clone.id = this.id.witClone; + clone.name = this.name.witClone; + clone.description = this.description.witClone; + clone.packFormat = this.packFormat.witClone; + clone.isEnabled = this.isEnabled.witClone; + clone.recipeCount = this.recipeCount.witClone; + clone.functionCount = this.functionCount.witClone; + return clone; + } +} + +/++ +Position options for enabling a datapack relative to other packs. ++/ +struct EnablePosition { + mixin WitVariant!( + void, // first + void, // last + WitString, // before + WitString, // after + ); + +public: + enum Tag : ubyte { + /++ + + +/ + first, + + /++ + + +/ + last, + + /++ + + +/ + before, + + /++ + + +/ + after, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias first = _create!(Tag.first); + /// ditto + pragma(inline, true) bool isFirst() const => _tag == Tag.first; + + /++ + + +/ + alias last = _create!(Tag.last); + /// ditto + pragma(inline, true) bool isLast() const => _tag == Tag.last; + + /++ + + +/ + alias before = _create!(Tag.before); + /// ditto + pragma(inline, true) bool isBefore() const => _tag == Tag.before; + ///ditto + alias getBefore = _get!(Tag.before); + + /++ + + +/ + alias after = _create!(Tag.after); + /// ditto + pragma(inline, true) bool isAfter() const => _tag == Tag.after; + ///ditto + alias getAfter = _get!(Tag.after); + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case before: _get!(Tag.before).witFree; break; + case after: _get!(Tag.after).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + } + + EnablePosition witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.first: return _create!(Tag.first); break; + case Tag.last: return _create!(Tag.last); break; + case Tag.before: return _create!(Tag.before)(this._get!(Tag.before).witClone); break; + case Tag.after: return _create!(Tag.after)(this._get!(Tag.after).witClone); break; + } + } +} diff --git a/src/wit/pumpkin/plugin/datapack/imports.d b/src/wit/pumpkin/plugin/datapack/imports.d new file mode 100644 index 0000000..e00b852 --- /dev/null +++ b/src/wit/pumpkin/plugin/datapack/imports.d @@ -0,0 +1,371 @@ +/++ + ++/ +module wit.pumpkin.plugin.datapack.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.datapack.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ +Global manager for inspecting and controlling server datapacks. ++/ +struct DatapackManager { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/datapack@0.1.0", "[resource-drop]datapack-manager") + pragma(mangle, "__wit_import_pumpkin:plugin__datapack@0.1.0__:resource_drop:datapack_manager") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + Returns all known datapacks (both enabled and available/disabled). + +/ + WitList!(DatapackInfo) listAllPacks() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_listAllPacks(this.__handle, _retArea.ptr); + auto _listSrcPtr8 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen8 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list8 = _listLen8 ? wit.common.mallocSlice!(DatapackInfo)(_listLen8) : []; + assert(!_listLen8 || _list8.ptr); + foreach (_elem0_idx, ref _elem0; _list8) { + const auto _base0 = _listSrcPtr8 + _elem0_idx * (16+6*size_t.sizeof); + auto _len1 = *(cast(size_t*)(_base0 + size_t.sizeof)); + auto _ptr1 = _len1 ? cast(char*)(*(cast(void**)(_base0 + 0))) : null; + auto _list2 = WitString(_ptr1[0.._len1]); + auto _len3 = *(cast(size_t*)(_base0 + (3*size_t.sizeof))); + auto _ptr3 = _len3 ? cast(char*)(*(cast(void**)(_base0 + (2*size_t.sizeof)))) : null; + auto _list4 = WitString(_ptr3[0.._len3]); + auto _len5 = *(cast(size_t*)(_base0 + (5*size_t.sizeof))); + auto _ptr5 = _len5 ? cast(char*)(*(cast(void**)(_base0 + (4*size_t.sizeof)))) : null; + auto _list6 = WitString(_ptr5[0.._len5]); + DatapackInfo _record7 = { + id: _list2, + name: _list4, + description: _list6, + packFormat: *(cast(uint*)(_base0 + (6*size_t.sizeof))), + isEnabled: (cast(uint)(*(cast(ubyte*)(_base0 + (4+6*size_t.sizeof))))) != 0, + recipeCount: *(cast(uint*)(_base0 + (8+6*size_t.sizeof))), + functionCount: *(cast(uint*)(_base0 + (12+6*size_t.sizeof))), + }; + _elem0 = _record7; + } + if (_listLen8) wit.common.free(_listSrcPtr8); + auto _witList9 = WitList!(DatapackInfo)(_list8); + auto _flush10 = _witList9; + return _flush10; + } + /// ditto + @wasmImport!("pumpkin:plugin/datapack@0.1.0", "[method]datapack-manager.list-all-packs") + pragma(mangle, "__wit_import_pumpkin:plugin__datapack@0.1.0__:method:datapack_manager.list_all_packs") + static private extern(C) void __import_listAllPacks(uint, void*) nothrow; + + /++ + Returns only currently enabled datapacks. + +/ + WitList!(DatapackInfo) listEnabledPacks() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_listEnabledPacks(this.__handle, _retArea.ptr); + auto _listSrcPtr8 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen8 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list8 = _listLen8 ? wit.common.mallocSlice!(DatapackInfo)(_listLen8) : []; + assert(!_listLen8 || _list8.ptr); + foreach (_elem0_idx, ref _elem0; _list8) { + const auto _base0 = _listSrcPtr8 + _elem0_idx * (16+6*size_t.sizeof); + auto _len1 = *(cast(size_t*)(_base0 + size_t.sizeof)); + auto _ptr1 = _len1 ? cast(char*)(*(cast(void**)(_base0 + 0))) : null; + auto _list2 = WitString(_ptr1[0.._len1]); + auto _len3 = *(cast(size_t*)(_base0 + (3*size_t.sizeof))); + auto _ptr3 = _len3 ? cast(char*)(*(cast(void**)(_base0 + (2*size_t.sizeof)))) : null; + auto _list4 = WitString(_ptr3[0.._len3]); + auto _len5 = *(cast(size_t*)(_base0 + (5*size_t.sizeof))); + auto _ptr5 = _len5 ? cast(char*)(*(cast(void**)(_base0 + (4*size_t.sizeof)))) : null; + auto _list6 = WitString(_ptr5[0.._len5]); + DatapackInfo _record7 = { + id: _list2, + name: _list4, + description: _list6, + packFormat: *(cast(uint*)(_base0 + (6*size_t.sizeof))), + isEnabled: (cast(uint)(*(cast(ubyte*)(_base0 + (4+6*size_t.sizeof))))) != 0, + recipeCount: *(cast(uint*)(_base0 + (8+6*size_t.sizeof))), + functionCount: *(cast(uint*)(_base0 + (12+6*size_t.sizeof))), + }; + _elem0 = _record7; + } + if (_listLen8) wit.common.free(_listSrcPtr8); + auto _witList9 = WitList!(DatapackInfo)(_list8); + auto _flush10 = _witList9; + return _flush10; + } + /// ditto + @wasmImport!("pumpkin:plugin/datapack@0.1.0", "[method]datapack-manager.list-enabled-packs") + pragma(mangle, "__wit_import_pumpkin:plugin__datapack@0.1.0__:method:datapack_manager.list_enabled_packs") + static private extern(C) void __import_listEnabledPacks(uint, void*) nothrow; + + /++ + Returns available (disabled) datapacks. + +/ + WitList!(DatapackInfo) listAvailablePacks() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_listAvailablePacks(this.__handle, _retArea.ptr); + auto _listSrcPtr8 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen8 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list8 = _listLen8 ? wit.common.mallocSlice!(DatapackInfo)(_listLen8) : []; + assert(!_listLen8 || _list8.ptr); + foreach (_elem0_idx, ref _elem0; _list8) { + const auto _base0 = _listSrcPtr8 + _elem0_idx * (16+6*size_t.sizeof); + auto _len1 = *(cast(size_t*)(_base0 + size_t.sizeof)); + auto _ptr1 = _len1 ? cast(char*)(*(cast(void**)(_base0 + 0))) : null; + auto _list2 = WitString(_ptr1[0.._len1]); + auto _len3 = *(cast(size_t*)(_base0 + (3*size_t.sizeof))); + auto _ptr3 = _len3 ? cast(char*)(*(cast(void**)(_base0 + (2*size_t.sizeof)))) : null; + auto _list4 = WitString(_ptr3[0.._len3]); + auto _len5 = *(cast(size_t*)(_base0 + (5*size_t.sizeof))); + auto _ptr5 = _len5 ? cast(char*)(*(cast(void**)(_base0 + (4*size_t.sizeof)))) : null; + auto _list6 = WitString(_ptr5[0.._len5]); + DatapackInfo _record7 = { + id: _list2, + name: _list4, + description: _list6, + packFormat: *(cast(uint*)(_base0 + (6*size_t.sizeof))), + isEnabled: (cast(uint)(*(cast(ubyte*)(_base0 + (4+6*size_t.sizeof))))) != 0, + recipeCount: *(cast(uint*)(_base0 + (8+6*size_t.sizeof))), + functionCount: *(cast(uint*)(_base0 + (12+6*size_t.sizeof))), + }; + _elem0 = _record7; + } + if (_listLen8) wit.common.free(_listSrcPtr8); + auto _witList9 = WitList!(DatapackInfo)(_list8); + auto _flush10 = _witList9; + return _flush10; + } + /// ditto + @wasmImport!("pumpkin:plugin/datapack@0.1.0", "[method]datapack-manager.list-available-packs") + pragma(mangle, "__wit_import_pumpkin:plugin__datapack@0.1.0__:method:datapack_manager.list_available_packs") + static private extern(C) void __import_listAvailablePacks(uint, void*) nothrow; + + /++ + Retrieves details about a specific datapack by name or ID. + +/ + Option!(DatapackInfo) getPack(in WitString name) @trusted nothrow { + align(size_t.sizeof) void[(16+7*size_t.sizeof)] _retArea = void; + __import_getPack(this.__handle, cast(void*)(name.ptr), name.length, _retArea.ptr); + Option!(DatapackInfo) _option9 = void; + bool _isSome9 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome9) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + auto _len4 = *(cast(size_t*)(_retArea.ptr + (4*size_t.sizeof))); + auto _ptr4 = _len4 ? cast(char*)(*(cast(void**)(_retArea.ptr + (3*size_t.sizeof)))) : null; + auto _list5 = WitString(_ptr4[0.._len4]); + auto _len6 = *(cast(size_t*)(_retArea.ptr + (6*size_t.sizeof))); + auto _ptr6 = _len6 ? cast(char*)(*(cast(void**)(_retArea.ptr + (5*size_t.sizeof)))) : null; + auto _list7 = WitString(_ptr6[0.._len6]); + DatapackInfo _record8 = { + id: _list3, + name: _list5, + description: _list7, + packFormat: *(cast(uint*)(_retArea.ptr + (7*size_t.sizeof))), + isEnabled: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (4+7*size_t.sizeof))))) != 0, + recipeCount: *(cast(uint*)(_retArea.ptr + (8+7*size_t.sizeof))), + functionCount: *(cast(uint*)(_retArea.ptr + (12+7*size_t.sizeof))), + }; + + _option9 = Option!(DatapackInfo).makeSome(_record8); + } else { + _option9 = Option!(DatapackInfo).makeNone; + } + auto _flush10 = _option9; + return _flush10; + } + /// ditto + @wasmImport!("pumpkin:plugin/datapack@0.1.0", "[method]datapack-manager.get-pack") + pragma(mangle, "__wit_import_pumpkin:plugin__datapack@0.1.0__:method:datapack_manager.get_pack") + static private extern(C) void __import_getPack(uint, void*, size_t, void*) nothrow; + + /++ + Checks if a datapack is currently enabled. + +/ + bool isEnabled(in WitString name) @trusted nothrow { + auto _ret = __import_isEnabled(this.__handle, cast(void*)(name.ptr), name.length); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/datapack@0.1.0", "[method]datapack-manager.is-enabled") + pragma(mangle, "__wit_import_pumpkin:plugin__datapack@0.1.0__:method:datapack_manager.is_enabled") + static private extern(C) uint __import_isEnabled(uint, void*, size_t) nothrow; + + /++ + Enables a datapack with a specific priority position. + +/ + Result!(void, WitString) enablePack(in WitString name, in EnablePosition position) @trusted nothrow { + align(size_t.sizeof) void[(3*size_t.sizeof)] _retArea = void; + uint _variantPart8 = void; + void* _variantPart9 = void; + size_t _variantPart10 = void; + alias _Tag11 = EnablePosition.Tag; + final switch (position.tag) { + case _Tag11.first: { + _variantPart8 = 0; + _variantPart9 = null; + _variantPart10 = 0; + break; + } + case _Tag11.last: { + _variantPart8 = 1; + _variantPart9 = null; + _variantPart10 = 0; + break; + } + case _Tag11.before: { + const ref WitString _payload5 = position.getBefore(); + _variantPart8 = 2; + _variantPart9 = cast(void*)(_payload5.ptr); + _variantPart10 = _payload5.length; + break; + } + case _Tag11.after: { + const ref WitString _payload7 = position.getAfter(); + _variantPart8 = 3; + _variantPart9 = cast(void*)(_payload7.ptr); + _variantPart10 = _payload7.length; + break; + } + } + __import_enablePack(this.__handle, cast(void*)(name.ptr), name.length, _variantPart8, _variantPart9, _variantPart10, _retArea.ptr); + Result!(void, WitString) _result16 = void; + bool _isErr16 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isErr16) { + auto _len14 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr14 = _len14 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list15 = WitString(_ptr14[0.._len14]); + + _result16 = Result!(void, WitString).makeErr(_list15); + } else { + + _result16 = Result!(void, WitString).makeOk(); + } + auto _flush17 = _result16; + return _flush17; + } + /// ditto + @wasmImport!("pumpkin:plugin/datapack@0.1.0", "[method]datapack-manager.enable-pack") + pragma(mangle, "__wit_import_pumpkin:plugin__datapack@0.1.0__:method:datapack_manager.enable_pack") + static private extern(C) void __import_enablePack(uint, void*, size_t, uint, void*, size_t, void*) nothrow; + + /++ + Disables an enabled datapack. + +/ + Result!(void, WitString) disablePack(in WitString name) @trusted nothrow { + align(size_t.sizeof) void[(3*size_t.sizeof)] _retArea = void; + __import_disablePack(this.__handle, cast(void*)(name.ptr), name.length, _retArea.ptr); + Result!(void, WitString) _result4 = void; + bool _isErr4 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isErr4) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + + _result4 = Result!(void, WitString).makeErr(_list3); + } else { + + _result4 = Result!(void, WitString).makeOk(); + } + auto _flush5 = _result4; + return _flush5; + } + /// ditto + @wasmImport!("pumpkin:plugin/datapack@0.1.0", "[method]datapack-manager.disable-pack") + pragma(mangle, "__wit_import_pumpkin:plugin__datapack@0.1.0__:method:datapack_manager.disable_pack") + static private extern(C) void __import_disablePack(uint, void*, size_t, void*) nothrow; + + /++ + Reloads all enabled datapacks, recipes, and function tags, + synchronizes recipes with online players, and triggers `#minecraft:load`. + +/ + Result!(void, WitString) reload() @trusted nothrow { + align(size_t.sizeof) void[(3*size_t.sizeof)] _retArea = void; + __import_reload(this.__handle, _retArea.ptr); + Result!(void, WitString) _result4 = void; + bool _isErr4 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isErr4) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + + _result4 = Result!(void, WitString).makeErr(_list3); + } else { + + _result4 = Result!(void, WitString).makeOk(); + } + auto _flush5 = _result4; + return _flush5; + } + /// ditto + @wasmImport!("pumpkin:plugin/datapack@0.1.0", "[method]datapack-manager.reload") + pragma(mangle, "__wit_import_pumpkin:plugin__datapack@0.1.0__:method:datapack_manager.reload") + static private extern(C) void __import_reload(uint, void*) nothrow; + + /++ + Executes a datapack function or function tag (e.g. "namespace:fn" or "#namespace:tag"). + Returns the number of commands executed. + +/ + Result!(uint, WitString) executeFunction(in WitString name) @trusted nothrow { + align(size_t.sizeof) void[(3*size_t.sizeof)] _retArea = void; + __import_executeFunction(this.__handle, cast(void*)(name.ptr), name.length, _retArea.ptr); + Result!(uint, WitString) _result4 = void; + bool _isErr4 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isErr4) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + + _result4 = Result!(uint, WitString).makeErr(_list3); + } else { + + _result4 = Result!(uint, WitString).makeOk(*(cast(uint*)(_retArea.ptr + size_t.sizeof))); + } + auto _flush5 = _result4; + return _flush5; + } + /// ditto + @wasmImport!("pumpkin:plugin/datapack@0.1.0", "[method]datapack-manager.execute-function") + pragma(mangle, "__wit_import_pumpkin:plugin__datapack@0.1.0__:method:datapack_manager.execute_function") + static private extern(C) void __import_executeFunction(uint, void*, size_t, void*) nothrow; + } +} diff --git a/src/wit/pumpkin/plugin/display/common.d b/src/wit/pumpkin/plugin/display/common.d new file mode 100644 index 0000000..0d8f825 --- /dev/null +++ b/src/wit/pumpkin/plugin/display/common.d @@ -0,0 +1,225 @@ +/++ + ++/ +module wit.pumpkin.plugin.display.common; + + +import wit.common; + +static import wit.pumpkin.plugin.text.common; +static import wit.pumpkin.plugin.item_stack.common; +static import wit.pumpkin.plugin.uuid.common; +static import wit.pumpkin.plugin.world.common; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias Uuid = wit.pumpkin.plugin.uuid.common.Uuid; + +/++ +Billboard rendering constraints for display entities. ++/ +enum BillboardMode : ubyte { + /++ + + +/ + fixed, + + /++ + + +/ + vertical, + + /++ + + +/ + horizontal, + + /++ + + +/ + center, +} +/++ +Item display transformation modes for item display entities. ++/ +enum ItemDisplayMode : ubyte { + /++ + + +/ + none, + + /++ + + +/ + thirdpersonLefthand, + + /++ + + +/ + thirdpersonRighthand, + + /++ + + +/ + firstpersonLefthand, + + /++ + + +/ + firstpersonRighthand, + + /++ + + +/ + head, + + /++ + + +/ + gui, + + /++ + + +/ + ground, + + /++ + + +/ + fixed, +} +/++ +Text alignment options for text display entities. ++/ +enum TextAlignment : ubyte { + /++ + + +/ + center, + + /++ + + +/ + left, + + /++ + + +/ + right, +} +/++ +3D single-precision vector. ++/ +struct Vector3f { + /++ + + +/ + float x; + + /++ + + +/ + float y; + + /++ + + +/ + float z; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + Vector3f witClone() const @nogc nothrow { + Vector3f clone = void; + clone.x = this.x.witClone; + clone.y = this.y.witClone; + clone.z = this.z.witClone; + return clone; + } +} + +/++ +Single-precision quaternion representing a 3D rotation. ++/ +struct Quaternionf { + /++ + + +/ + float x; + + /++ + + +/ + float y; + + /++ + + +/ + float z; + + /++ + + +/ + float w; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + Quaternionf witClone() const @nogc nothrow { + Quaternionf clone = void; + clone.x = this.x.witClone; + clone.y = this.y.witClone; + clone.z = this.z.witClone; + clone.w = this.w.witClone; + return clone; + } +} + +/++ +Transformation (translation, scale, left and right rotations) for display entities. ++/ +struct DisplayTransformation { + /++ + + +/ + Vector3f translation; + + /++ + + +/ + Vector3f scale; + + /++ + + +/ + Quaternionf leftRotation; + + /++ + + +/ + Quaternionf rightRotation; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + DisplayTransformation witClone() const @nogc nothrow { + DisplayTransformation clone = void; + clone.translation = this.translation.witClone; + clone.scale = this.scale.witClone; + clone.leftRotation = this.leftRotation.witClone; + clone.rightRotation = this.rightRotation.witClone; + return clone; + } +} diff --git a/src/wit/pumpkin/plugin/display/imports.d b/src/wit/pumpkin/plugin/display/imports.d new file mode 100644 index 0000000..12d3e47 --- /dev/null +++ b/src/wit/pumpkin/plugin/display/imports.d @@ -0,0 +1,1167 @@ +/++ + ++/ +module wit.pumpkin.plugin.display.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.display.common; + +static import wit.pumpkin.plugin.text.imports; +static import wit.pumpkin.plugin.item_stack.imports; +static import wit.pumpkin.plugin.uuid.imports; +static import wit.pumpkin.plugin.world.imports; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias Entity = wit.pumpkin.plugin.world.imports.Entity; + +/++ + ++/ +alias TextComponent = wit.pumpkin.plugin.text.imports.TextComponent; + +/++ + ++/ +alias ItemStack = wit.pumpkin.plugin.item_stack.imports.ItemStack; + +/++ +Common base resource for all display entities. ++/ +struct DisplayEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + /++ + + +/ + static Option!(DisplayEntity) fromEntity(Entity.Borrow entity) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_fromEntity(entity.__handle, _retArea.ptr); + Option!(DisplayEntity) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = DisplayEntity(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(DisplayEntity).makeSome(_handle2); + } else { + _option3 = Option!(DisplayEntity).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[static]display-entity.from-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:static:display_entity.from_entity") + static private extern(C) void __import_fromEntity(uint, void*) nothrow; + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/display@0.1.0", "[resource-drop]display-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:resource_drop:display_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + Entity getEntity() @trusted nothrow { + auto _ret = __import_getEntity(this.__handle); + auto _handle0 = Entity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.get-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.get_entity") + static private extern(C) uint __import_getEntity(uint) nothrow; + + /++ + + +/ + DisplayTransformation getTransformation() @trusted nothrow { + align(4) void[56] _retArea = void; + __import_getTransformation(this.__handle, _retArea.ptr); + Vector3f _record0 = { + x: *(cast(float*)(_retArea.ptr + 0)), + y: *(cast(float*)(_retArea.ptr + 4)), + z: *(cast(float*)(_retArea.ptr + 8)), + }; + Vector3f _record1 = { + x: *(cast(float*)(_retArea.ptr + 12)), + y: *(cast(float*)(_retArea.ptr + 16)), + z: *(cast(float*)(_retArea.ptr + 20)), + }; + Quaternionf _record2 = { + x: *(cast(float*)(_retArea.ptr + 24)), + y: *(cast(float*)(_retArea.ptr + 28)), + z: *(cast(float*)(_retArea.ptr + 32)), + w: *(cast(float*)(_retArea.ptr + 36)), + }; + Quaternionf _record3 = { + x: *(cast(float*)(_retArea.ptr + 40)), + y: *(cast(float*)(_retArea.ptr + 44)), + z: *(cast(float*)(_retArea.ptr + 48)), + w: *(cast(float*)(_retArea.ptr + 52)), + }; + DisplayTransformation _record4 = { + translation: _record0, + scale: _record1, + leftRotation: _record2, + rightRotation: _record3, + }; + auto _flush5 = _record4; + return _flush5; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.get-transformation") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.get_transformation") + static private extern(C) void __import_getTransformation(uint, void*) nothrow; + + /++ + + +/ + void setTransformation(in DisplayTransformation transformation) @trusted nothrow { + __import_setTransformation(this.__handle, transformation.translation.x, transformation.translation.y, transformation.translation.z, transformation.scale.x, transformation.scale.y, transformation.scale.z, transformation.leftRotation.x, transformation.leftRotation.y, transformation.leftRotation.z, transformation.leftRotation.w, transformation.rightRotation.x, transformation.rightRotation.y, transformation.rightRotation.z, transformation.rightRotation.w); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.set-transformation") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.set_transformation") + static private extern(C) void __import_setTransformation(uint, float, float, float, float, float, float, float, float, float, float, float, float, float, float) nothrow; + + /++ + + +/ + int getInterpolationDuration() @trusted nothrow { + auto _ret = __import_getInterpolationDuration(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.get-interpolation-duration") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.get_interpolation_duration") + static private extern(C) uint __import_getInterpolationDuration(uint) nothrow; + + /++ + + +/ + void setInterpolationDuration(int duration) @trusted nothrow { + __import_setInterpolationDuration(this.__handle, cast(uint)(duration)); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.set-interpolation-duration") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.set_interpolation_duration") + static private extern(C) void __import_setInterpolationDuration(uint, uint) nothrow; + + /++ + + +/ + int getInterpolationStart() @trusted nothrow { + auto _ret = __import_getInterpolationStart(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.get-interpolation-start") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.get_interpolation_start") + static private extern(C) uint __import_getInterpolationStart(uint) nothrow; + + /++ + + +/ + void setInterpolationStart(int deltaTicks) @trusted nothrow { + __import_setInterpolationStart(this.__handle, cast(uint)(deltaTicks)); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.set-interpolation-start") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.set_interpolation_start") + static private extern(C) void __import_setInterpolationStart(uint, uint) nothrow; + + /++ + + +/ + int getTeleportDuration() @trusted nothrow { + auto _ret = __import_getTeleportDuration(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.get-teleport-duration") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.get_teleport_duration") + static private extern(C) uint __import_getTeleportDuration(uint) nothrow; + + /++ + + +/ + void setTeleportDuration(int duration) @trusted nothrow { + __import_setTeleportDuration(this.__handle, cast(uint)(duration)); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.set-teleport-duration") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.set_teleport_duration") + static private extern(C) void __import_setTeleportDuration(uint, uint) nothrow; + + /++ + + +/ + BillboardMode getBillboard() @trusted nothrow { + auto _ret = __import_getBillboard(this.__handle); + return cast(BillboardMode)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.get-billboard") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.get_billboard") + static private extern(C) uint __import_getBillboard(uint) nothrow; + + /++ + + +/ + void setBillboard(BillboardMode mode) @trusted nothrow { + __import_setBillboard(this.__handle, cast(uint)(mode)); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.set-billboard") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.set_billboard") + static private extern(C) void __import_setBillboard(uint, uint) nothrow; + + /++ + + +/ + float getViewRange() @trusted nothrow { + auto _ret = __import_getViewRange(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.get-view-range") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.get_view_range") + static private extern(C) float __import_getViewRange(uint) nothrow; + + /++ + + +/ + void setViewRange(float range) @trusted nothrow { + __import_setViewRange(this.__handle, range); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.set-view-range") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.set_view_range") + static private extern(C) void __import_setViewRange(uint, float) nothrow; + + /++ + + +/ + float getShadowRadius() @trusted nothrow { + auto _ret = __import_getShadowRadius(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.get-shadow-radius") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.get_shadow_radius") + static private extern(C) float __import_getShadowRadius(uint) nothrow; + + /++ + + +/ + void setShadowRadius(float radius) @trusted nothrow { + __import_setShadowRadius(this.__handle, radius); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.set-shadow-radius") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.set_shadow_radius") + static private extern(C) void __import_setShadowRadius(uint, float) nothrow; + + /++ + + +/ + float getShadowStrength() @trusted nothrow { + auto _ret = __import_getShadowStrength(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.get-shadow-strength") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.get_shadow_strength") + static private extern(C) float __import_getShadowStrength(uint) nothrow; + + /++ + + +/ + void setShadowStrength(float strength) @trusted nothrow { + __import_setShadowStrength(this.__handle, strength); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.set-shadow-strength") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.set_shadow_strength") + static private extern(C) void __import_setShadowStrength(uint, float) nothrow; + + /++ + + +/ + float getDisplayWidth() @trusted nothrow { + auto _ret = __import_getDisplayWidth(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.get-display-width") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.get_display_width") + static private extern(C) float __import_getDisplayWidth(uint) nothrow; + + /++ + + +/ + void setDisplayWidth(float width) @trusted nothrow { + __import_setDisplayWidth(this.__handle, width); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.set-display-width") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.set_display_width") + static private extern(C) void __import_setDisplayWidth(uint, float) nothrow; + + /++ + + +/ + float getDisplayHeight() @trusted nothrow { + auto _ret = __import_getDisplayHeight(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.get-display-height") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.get_display_height") + static private extern(C) float __import_getDisplayHeight(uint) nothrow; + + /++ + + +/ + void setDisplayHeight(float height) @trusted nothrow { + __import_setDisplayHeight(this.__handle, height); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.set-display-height") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.set_display_height") + static private extern(C) void __import_setDisplayHeight(uint, float) nothrow; + + /++ + + +/ + int getGlowColorOverride() @trusted nothrow { + auto _ret = __import_getGlowColorOverride(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.get-glow-color-override") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.get_glow_color_override") + static private extern(C) uint __import_getGlowColorOverride(uint) nothrow; + + /++ + + +/ + void setGlowColorOverride(int color) @trusted nothrow { + __import_setGlowColorOverride(this.__handle, cast(uint)(color)); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.set-glow-color-override") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.set_glow_color_override") + static private extern(C) void __import_setGlowColorOverride(uint, uint) nothrow; + + /++ + + +/ + int getBrightness() @trusted nothrow { + auto _ret = __import_getBrightness(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.get-brightness") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.get_brightness") + static private extern(C) uint __import_getBrightness(uint) nothrow; + + /++ + + +/ + void setBrightness(int brightness) @trusted nothrow { + __import_setBrightness(this.__handle, cast(uint)(brightness)); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]display-entity.set-brightness") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:display_entity.set_brightness") + static private extern(C) void __import_setBrightness(uint, uint) nothrow; + } +} + +/++ +Resource specifically for Block Display entities. ++/ +struct BlockDisplayEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + /++ + + +/ + static Option!(BlockDisplayEntity) fromEntity(Entity.Borrow entity) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_fromEntity(entity.__handle, _retArea.ptr); + Option!(BlockDisplayEntity) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = BlockDisplayEntity(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(BlockDisplayEntity).makeSome(_handle2); + } else { + _option3 = Option!(BlockDisplayEntity).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[static]block-display-entity.from-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:static:block_display_entity.from_entity") + static private extern(C) void __import_fromEntity(uint, void*) nothrow; + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/display@0.1.0", "[resource-drop]block-display-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:resource_drop:block_display_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + DisplayEntity getDisplay() @trusted nothrow { + auto _ret = __import_getDisplay(this.__handle); + auto _handle0 = DisplayEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]block-display-entity.get-display") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:block_display_entity.get_display") + static private extern(C) uint __import_getDisplay(uint) nothrow; + + /++ + + +/ + Entity getEntity() @trusted nothrow { + auto _ret = __import_getEntity(this.__handle); + auto _handle0 = Entity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]block-display-entity.get-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:block_display_entity.get_entity") + static private extern(C) uint __import_getEntity(uint) nothrow; + + /++ + + +/ + ushort getBlockStateId() @trusted nothrow { + auto _ret = __import_getBlockStateId(this.__handle); + return cast(ushort)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]block-display-entity.get-block-state-id") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:block_display_entity.get_block_state_id") + static private extern(C) uint __import_getBlockStateId(uint) nothrow; + + /++ + + +/ + void setBlockStateId(ushort stateId) @trusted nothrow { + __import_setBlockStateId(this.__handle, cast(uint)(stateId)); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]block-display-entity.set-block-state-id") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:block_display_entity.set_block_state_id") + static private extern(C) void __import_setBlockStateId(uint, uint) nothrow; + } +} + +/++ +Resource specifically for Item Display entities. ++/ +struct ItemDisplayEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + /++ + + +/ + static Option!(ItemDisplayEntity) fromEntity(Entity.Borrow entity) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_fromEntity(entity.__handle, _retArea.ptr); + Option!(ItemDisplayEntity) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = ItemDisplayEntity(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(ItemDisplayEntity).makeSome(_handle2); + } else { + _option3 = Option!(ItemDisplayEntity).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[static]item-display-entity.from-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:static:item_display_entity.from_entity") + static private extern(C) void __import_fromEntity(uint, void*) nothrow; + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/display@0.1.0", "[resource-drop]item-display-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:resource_drop:item_display_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + DisplayEntity getDisplay() @trusted nothrow { + auto _ret = __import_getDisplay(this.__handle); + auto _handle0 = DisplayEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]item-display-entity.get-display") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:item_display_entity.get_display") + static private extern(C) uint __import_getDisplay(uint) nothrow; + + /++ + + +/ + Entity getEntity() @trusted nothrow { + auto _ret = __import_getEntity(this.__handle); + auto _handle0 = Entity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]item-display-entity.get-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:item_display_entity.get_entity") + static private extern(C) uint __import_getEntity(uint) nothrow; + + /++ + + +/ + Option!(ItemStack) getItem() @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getItem(this.__handle, _retArea.ptr); + Option!(ItemStack) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = ItemStack(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(ItemStack).makeSome(_handle2); + } else { + _option3 = Option!(ItemStack).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]item-display-entity.get-item") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:item_display_entity.get_item") + static private extern(C) void __import_getItem(uint, void*) nothrow; + + /++ + + +/ + void setItem(in Option!(ItemStack) item) @trusted nothrow { + uint _option4 = void; + uint _option5 = void; + if (item.isSome) { + ref _payload3 = item.unwrap(); + _option4 = 1; + _option5 = _payload3.__handle; + } else { + _option4 = 0; + _option5 = 0; + } + __import_setItem(this.__handle, _option4, _option5); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]item-display-entity.set-item") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:item_display_entity.set_item") + static private extern(C) void __import_setItem(uint, uint, uint) nothrow; + + /++ + + +/ + ItemDisplayMode getItemDisplayMode() @trusted nothrow { + auto _ret = __import_getItemDisplayMode(this.__handle); + return cast(ItemDisplayMode)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]item-display-entity.get-item-display-mode") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:item_display_entity.get_item_display_mode") + static private extern(C) uint __import_getItemDisplayMode(uint) nothrow; + + /++ + + +/ + void setItemDisplayMode(ItemDisplayMode mode) @trusted nothrow { + __import_setItemDisplayMode(this.__handle, cast(uint)(mode)); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]item-display-entity.set-item-display-mode") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:item_display_entity.set_item_display_mode") + static private extern(C) void __import_setItemDisplayMode(uint, uint) nothrow; + } +} + +/++ +Resource specifically for Text Display entities. ++/ +struct TextDisplayEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + /++ + + +/ + static Option!(TextDisplayEntity) fromEntity(Entity.Borrow entity) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_fromEntity(entity.__handle, _retArea.ptr); + Option!(TextDisplayEntity) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = TextDisplayEntity(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(TextDisplayEntity).makeSome(_handle2); + } else { + _option3 = Option!(TextDisplayEntity).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[static]text-display-entity.from-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:static:text_display_entity.from_entity") + static private extern(C) void __import_fromEntity(uint, void*) nothrow; + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/display@0.1.0", "[resource-drop]text-display-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:resource_drop:text_display_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + DisplayEntity getDisplay() @trusted nothrow { + auto _ret = __import_getDisplay(this.__handle); + auto _handle0 = DisplayEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]text-display-entity.get-display") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:text_display_entity.get_display") + static private extern(C) uint __import_getDisplay(uint) nothrow; + + /++ + + +/ + Entity getEntity() @trusted nothrow { + auto _ret = __import_getEntity(this.__handle); + auto _handle0 = Entity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]text-display-entity.get-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:text_display_entity.get_entity") + static private extern(C) uint __import_getEntity(uint) nothrow; + + /++ + + +/ + TextComponent getText() @trusted nothrow { + auto _ret = __import_getText(this.__handle); + auto _handle0 = TextComponent(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]text-display-entity.get-text") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:text_display_entity.get_text") + static private extern(C) uint __import_getText(uint) nothrow; + + /++ + + +/ + void setText(TextComponent text) @trusted nothrow { + __import_setText(this.__handle, text.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]text-display-entity.set-text") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:text_display_entity.set_text") + static private extern(C) void __import_setText(uint, uint) nothrow; + + /++ + + +/ + int getLineWidth() @trusted nothrow { + auto _ret = __import_getLineWidth(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]text-display-entity.get-line-width") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:text_display_entity.get_line_width") + static private extern(C) uint __import_getLineWidth(uint) nothrow; + + /++ + + +/ + void setLineWidth(int width) @trusted nothrow { + __import_setLineWidth(this.__handle, cast(uint)(width)); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]text-display-entity.set-line-width") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:text_display_entity.set_line_width") + static private extern(C) void __import_setLineWidth(uint, uint) nothrow; + + /++ + + +/ + int getBackground() @trusted nothrow { + auto _ret = __import_getBackground(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]text-display-entity.get-background") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:text_display_entity.get_background") + static private extern(C) uint __import_getBackground(uint) nothrow; + + /++ + + +/ + void setBackground(int color) @trusted nothrow { + __import_setBackground(this.__handle, cast(uint)(color)); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]text-display-entity.set-background") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:text_display_entity.set_background") + static private extern(C) void __import_setBackground(uint, uint) nothrow; + + /++ + + +/ + byte getTextOpacity() @trusted nothrow { + auto _ret = __import_getTextOpacity(this.__handle); + return cast(byte)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]text-display-entity.get-text-opacity") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:text_display_entity.get_text_opacity") + static private extern(C) uint __import_getTextOpacity(uint) nothrow; + + /++ + + +/ + void setTextOpacity(byte opacity) @trusted nothrow { + __import_setTextOpacity(this.__handle, cast(uint)(opacity)); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]text-display-entity.set-text-opacity") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:text_display_entity.set_text_opacity") + static private extern(C) void __import_setTextOpacity(uint, uint) nothrow; + + /++ + + +/ + bool getShadow() @trusted nothrow { + auto _ret = __import_getShadow(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]text-display-entity.get-shadow") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:text_display_entity.get_shadow") + static private extern(C) uint __import_getShadow(uint) nothrow; + + /++ + + +/ + void setShadow(bool shadow) @trusted nothrow { + __import_setShadow(this.__handle, cast(uint)(shadow)); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]text-display-entity.set-shadow") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:text_display_entity.set_shadow") + static private extern(C) void __import_setShadow(uint, uint) nothrow; + + /++ + + +/ + bool getSeeThrough() @trusted nothrow { + auto _ret = __import_getSeeThrough(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]text-display-entity.get-see-through") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:text_display_entity.get_see_through") + static private extern(C) uint __import_getSeeThrough(uint) nothrow; + + /++ + + +/ + void setSeeThrough(bool seeThrough) @trusted nothrow { + __import_setSeeThrough(this.__handle, cast(uint)(seeThrough)); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]text-display-entity.set-see-through") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:text_display_entity.set_see_through") + static private extern(C) void __import_setSeeThrough(uint, uint) nothrow; + + /++ + + +/ + bool getDefaultBackground() @trusted nothrow { + auto _ret = __import_getDefaultBackground(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]text-display-entity.get-default-background") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:text_display_entity.get_default_background") + static private extern(C) uint __import_getDefaultBackground(uint) nothrow; + + /++ + + +/ + void setDefaultBackground(bool defaultBackground) @trusted nothrow { + __import_setDefaultBackground(this.__handle, cast(uint)(defaultBackground)); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]text-display-entity.set-default-background") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:text_display_entity.set_default_background") + static private extern(C) void __import_setDefaultBackground(uint, uint) nothrow; + + /++ + + +/ + TextAlignment getAlignment() @trusted nothrow { + auto _ret = __import_getAlignment(this.__handle); + return cast(TextAlignment)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]text-display-entity.get-alignment") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:text_display_entity.get_alignment") + static private extern(C) uint __import_getAlignment(uint) nothrow; + + /++ + + +/ + void setAlignment(TextAlignment alignment) @trusted nothrow { + __import_setAlignment(this.__handle, cast(uint)(alignment)); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]text-display-entity.set-alignment") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:text_display_entity.set_alignment") + static private extern(C) void __import_setAlignment(uint, uint) nothrow; + } +} + +/++ +Resource specifically for Interaction entities. ++/ +struct InteractionEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + /++ + + +/ + static Option!(InteractionEntity) fromEntity(Entity.Borrow entity) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_fromEntity(entity.__handle, _retArea.ptr); + Option!(InteractionEntity) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = InteractionEntity(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(InteractionEntity).makeSome(_handle2); + } else { + _option3 = Option!(InteractionEntity).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[static]interaction-entity.from-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:static:interaction_entity.from_entity") + static private extern(C) void __import_fromEntity(uint, void*) nothrow; + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/display@0.1.0", "[resource-drop]interaction-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:resource_drop:interaction_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + Entity getEntity() @trusted nothrow { + auto _ret = __import_getEntity(this.__handle); + auto _handle0 = Entity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]interaction-entity.get-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:interaction_entity.get_entity") + static private extern(C) uint __import_getEntity(uint) nothrow; + + /++ + + +/ + float getWidth() @trusted nothrow { + auto _ret = __import_getWidth(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]interaction-entity.get-width") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:interaction_entity.get_width") + static private extern(C) float __import_getWidth(uint) nothrow; + + /++ + + +/ + void setWidth(float width) @trusted nothrow { + __import_setWidth(this.__handle, width); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]interaction-entity.set-width") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:interaction_entity.set_width") + static private extern(C) void __import_setWidth(uint, float) nothrow; + + /++ + + +/ + float getHeight() @trusted nothrow { + auto _ret = __import_getHeight(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]interaction-entity.get-height") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:interaction_entity.get_height") + static private extern(C) float __import_getHeight(uint) nothrow; + + /++ + + +/ + void setHeight(float height) @trusted nothrow { + __import_setHeight(this.__handle, height); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]interaction-entity.set-height") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:interaction_entity.set_height") + static private extern(C) void __import_setHeight(uint, float) nothrow; + + /++ + + +/ + bool getResponse() @trusted nothrow { + auto _ret = __import_getResponse(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]interaction-entity.get-response") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:interaction_entity.get_response") + static private extern(C) uint __import_getResponse(uint) nothrow; + + /++ + + +/ + void setResponse(bool response) @trusted nothrow { + __import_setResponse(this.__handle, cast(uint)(response)); + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]interaction-entity.set-response") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:interaction_entity.set_response") + static private extern(C) void __import_setResponse(uint, uint) nothrow; + + /++ + + +/ + Option!(Uuid) getLastAttacker() @trusted nothrow { + align(8) void[24] _retArea = void; + __import_getLastAttacker(this.__handle, _retArea.ptr); + Option!(Uuid) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + wit.pumpkin.plugin.uuid.imports.Uuid _record2 = { + high: *(cast(ulong*)(_retArea.ptr + 8)), + low: *(cast(ulong*)(_retArea.ptr + 16)), + }; + + _option3 = Option!(Uuid).makeSome(_record2); + } else { + _option3 = Option!(Uuid).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]interaction-entity.get-last-attacker") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:interaction_entity.get_last_attacker") + static private extern(C) void __import_getLastAttacker(uint, void*) nothrow; + + /++ + + +/ + Option!(Uuid) getLastInteraction() @trusted nothrow { + align(8) void[24] _retArea = void; + __import_getLastInteraction(this.__handle, _retArea.ptr); + Option!(Uuid) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + wit.pumpkin.plugin.uuid.imports.Uuid _record2 = { + high: *(cast(ulong*)(_retArea.ptr + 8)), + low: *(cast(ulong*)(_retArea.ptr + 16)), + }; + + _option3 = Option!(Uuid).makeSome(_record2); + } else { + _option3 = Option!(Uuid).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/display@0.1.0", "[method]interaction-entity.get-last-interaction") + pragma(mangle, "__wit_import_pumpkin:plugin__display@0.1.0__:method:interaction_entity.get_last_interaction") + static private extern(C) void __import_getLastInteraction(uint, void*) nothrow; + } +} diff --git a/src/wit/pumpkin/plugin/enchantments/common.d b/src/wit/pumpkin/plugin/enchantments/common.d new file mode 100644 index 0000000..c23b69e --- /dev/null +++ b/src/wit/pumpkin/plugin/enchantments/common.d @@ -0,0 +1,290 @@ +/++ + ++/ +module wit.pumpkin.plugin.enchantments.common; + + +import wit.common; + +static import wit.pumpkin.plugin.text.common; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ +Equipment slot where an enchantment is active. ++/ +enum AttributeModifierSlot : ubyte { + /++ + + +/ + any, + + /++ + + +/ + mainHand, + + /++ + + +/ + offHand, + + /++ + + +/ + hand, + + /++ + + +/ + feet, + + /++ + + +/ + legs, + + /++ + + +/ + chest, + + /++ + + +/ + head, + + /++ + + +/ + armor, + + /++ + + +/ + body_, + + /++ + + +/ + saddle, +} +/++ +Vanilla enchantments enum. ++/ +enum Enchantment : ubyte { + /++ + + +/ + aquaAffinity, + + /++ + + +/ + baneOfArthropods, + + /++ + + +/ + bindingCurse, + + /++ + + +/ + blastProtection, + + /++ + + +/ + breach, + + /++ + + +/ + channeling, + + /++ + + +/ + density, + + /++ + + +/ + depthStrider, + + /++ + + +/ + efficiency, + + /++ + + +/ + featherFalling, + + /++ + + +/ + fireAspect, + + /++ + + +/ + fireProtection, + + /++ + + +/ + flame, + + /++ + + +/ + fortune, + + /++ + + +/ + frostWalker, + + /++ + + +/ + impaling, + + /++ + + +/ + infinity, + + /++ + + +/ + knockback, + + /++ + + +/ + looting, + + /++ + + +/ + loyalty, + + /++ + + +/ + luckOfTheSea, + + /++ + + +/ + lunge, + + /++ + + +/ + lure, + + /++ + + +/ + mending, + + /++ + + +/ + multishot, + + /++ + + +/ + piercing, + + /++ + + +/ + power, + + /++ + + +/ + projectileProtection, + + /++ + + +/ + protection, + + /++ + + +/ + punch, + + /++ + + +/ + quickCharge, + + /++ + + +/ + respiration, + + /++ + + +/ + riptide, + + /++ + + +/ + sharpness, + + /++ + + +/ + silkTouch, + + /++ + + +/ + smite, + + /++ + + +/ + soulSpeed, + + /++ + + +/ + sweepingEdge, + + /++ + + +/ + swiftSneak, + + /++ + + +/ + thorns, + + /++ + + +/ + unbreaking, + + /++ + + +/ + vanishingCurse, + + /++ + + +/ + windBurst, +} \ No newline at end of file diff --git a/src/wit/pumpkin/plugin/enchantments/imports.d b/src/wit/pumpkin/plugin/enchantments/imports.d new file mode 100644 index 0000000..1af6965 --- /dev/null +++ b/src/wit/pumpkin/plugin/enchantments/imports.d @@ -0,0 +1,278 @@ +/++ + ++/ +module wit.pumpkin.plugin.enchantments.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.enchantments.common; + +static import wit.pumpkin.plugin.text.imports; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias TextComponent = wit.pumpkin.plugin.text.imports.TextComponent; + +/++ +Represents a custom enchantment definition. ++/ +struct CustomEnchantment { + /++ + Unique identifier for the enchantment (e.g. "my_plugin:lifesteal"). + +/ + WitString id; + + /++ + Description or display name of the enchantment. + +/ + TextComponent description; + + /++ + Maximum level of the enchantment (e.g. 1..=10). + +/ + uint maxLevel; + + /++ + Base anvil repair/combination cost multiplier. + +/ + uint anvilCost; + + /++ + Tag or item pattern for supported items (e.g. "#minecraft:enchantable/weapon"). + +/ + WitString supportedItems; + + /++ + Weight / rarity of the enchantment (higher = more common, default 5). + +/ + uint weight; + + /++ + Equipment slots where this enchantment is active. + +/ + WitList!(AttributeModifierSlot) slots; + + /++ + List of exclusive/conflicting enchantment IDs. + +/ + WitList!(WitString) exclusiveSet; + + void witFree() @nogc nothrow { + id.witFree; + supportedItems.witFree; + slots.witFree; + exclusiveSet.witFree; + } + + void witDrop() @nogc nothrow { + description.witDrop; + } + + CustomEnchantment witClone() const @nogc nothrow { + CustomEnchantment clone = void; + clone.id = this.id.witClone; + clone.description = this.description.witClone; + clone.maxLevel = this.maxLevel.witClone; + clone.anvilCost = this.anvilCost.witClone; + clone.supportedItems = this.supportedItems.witClone; + clone.weight = this.weight.witClone; + clone.slots = this.slots.witClone; + clone.exclusiveSet = this.exclusiveSet.witClone; + return clone; + } +} + +/++ +Global manager for registering and querying custom enchantments. ++/ +struct EnchantmentManager { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/enchantments@0.1.0", "[resource-drop]enchantment-manager") + pragma(mangle, "__wit_import_pumpkin:plugin__enchantments@0.1.0__:resource_drop:enchantment_manager") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + Registers a new custom enchantment with the server. + +/ + Result!(void, WitString) registerEnchantment(in CustomEnchantment enchantment) @trusted nothrow { + align(size_t.sizeof) void[(3*size_t.sizeof)] _retArea = void; + wit.common.DeallocateBuffer deallocate; + auto _listSrc1 = enchantment.slots; + auto _list1 = _listSrc1.length ? wit.common.malloc(_listSrc1.length * (1)) : null; + assert(!_listSrc1.length || _list1); + if (_listSrc1.length) deallocate ~= _list1; + foreach (_elem0_idx, ref _elem0; _listSrc1) { + auto _base0 = _list1 + _elem0_idx * (1); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(cast(uint)(_elem0)); + + } + auto _listSrc3 = enchantment.exclusiveSet; + auto _list3 = _listSrc3.length ? wit.common.malloc(_listSrc3.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc3.length || _list3); + if (_listSrc3.length) deallocate ~= _list3; + foreach (_elem2_idx, ref _elem2; _listSrc3) { + auto _base2 = _list3 + _elem2_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base2 + size_t.sizeof) = cast(size_t)(_elem2.length); + *cast(void**)(_base2 + 0) = cast(void*)(cast(void*)(_elem2.ptr)); + + } + __import_registerEnchantment(this.__handle, cast(void*)(enchantment.id.ptr), enchantment.id.length, enchantment.description.__handle, enchantment.maxLevel, enchantment.anvilCost, cast(void*)(enchantment.supportedItems.ptr), enchantment.supportedItems.length, enchantment.weight, _list1, enchantment.slots.length, _list3, enchantment.exclusiveSet.length, _retArea.ptr); + deallocate.purge(); + Result!(void, WitString) _result8 = void; + bool _isErr8 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isErr8) { + auto _len6 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr6 = _len6 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list7 = WitString(_ptr6[0.._len6]); + + _result8 = Result!(void, WitString).makeErr(_list7); + } else { + + _result8 = Result!(void, WitString).makeOk(); + } + auto _flush9 = _result8; + return _flush9; + } + /// ditto + @wasmImport!("pumpkin:plugin/enchantments@0.1.0", "[method]enchantment-manager.register-enchantment") + pragma(mangle, "__wit_import_pumpkin:plugin__enchantments@0.1.0__:method:enchantment_manager.register_enchantment") + static private extern(C) void __import_registerEnchantment(uint, void*, size_t, uint, uint, uint, void*, size_t, uint, void*, size_t, void*, size_t, void*) nothrow; + + /++ + Gets an enchantment definition by its ID. + +/ + Option!(CustomEnchantment) getEnchantment(in WitString id) @trusted nothrow { + align(size_t.sizeof) void[(8+11*size_t.sizeof)] _retArea = void; + __import_getEnchantment(this.__handle, cast(void*)(id.ptr), id.length, _retArea.ptr); + Option!(CustomEnchantment) _option16 = void; + bool _isSome16 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome16) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + auto _handle4 = TextComponent(*(cast(uint*)(_retArea.ptr + (3*size_t.sizeof)))); + auto _len5 = *(cast(size_t*)(_retArea.ptr + (8+5*size_t.sizeof))); + auto _ptr5 = _len5 ? cast(char*)(*(cast(void**)(_retArea.ptr + (8+4*size_t.sizeof)))) : null; + auto _list6 = WitString(_ptr5[0.._len5]); + auto _listSrcPtr8 = *(cast(void**)(_retArea.ptr + (8+7*size_t.sizeof))); + auto _listLen8 = *(cast(size_t*)(_retArea.ptr + (8+8*size_t.sizeof))); + auto _list8 = _listLen8 ? wit.common.mallocSlice!(AttributeModifierSlot)(_listLen8) : []; + assert(!_listLen8 || _list8.ptr); + foreach (_elem7_idx, ref _elem7; _list8) { + const auto _base7 = _listSrcPtr8 + _elem7_idx * 1; + _elem7 = cast(AttributeModifierSlot)(cast(uint)(*(cast(ubyte*)(_base7 + 0)))); + } + if (_listLen8) wit.common.free(_listSrcPtr8); + auto _witList9 = WitList!(AttributeModifierSlot)(_list8); + auto _listSrcPtr13 = *(cast(void**)(_retArea.ptr + (8+9*size_t.sizeof))); + auto _listLen13 = *(cast(size_t*)(_retArea.ptr + (8+10*size_t.sizeof))); + auto _list13 = _listLen13 ? wit.common.mallocSlice!(WitString)(_listLen13) : []; + assert(!_listLen13 || _list13.ptr); + foreach (_elem10_idx, ref _elem10; _list13) { + const auto _base10 = _listSrcPtr13 + _elem10_idx * (2*size_t.sizeof); + auto _len11 = *(cast(size_t*)(_base10 + size_t.sizeof)); + auto _ptr11 = _len11 ? cast(char*)(*(cast(void**)(_base10 + 0))) : null; + auto _list12 = WitString(_ptr11[0.._len11]); + _elem10 = _list12; + } + if (_listLen13) wit.common.free(_listSrcPtr13); + auto _witList14 = WitList!(WitString)(_list13); + CustomEnchantment _record15 = { + id: _list3, + description: _handle4, + maxLevel: *(cast(uint*)(_retArea.ptr + (4+3*size_t.sizeof))), + anvilCost: *(cast(uint*)(_retArea.ptr + (8+3*size_t.sizeof))), + supportedItems: _list6, + weight: *(cast(uint*)(_retArea.ptr + (8+6*size_t.sizeof))), + slots: _witList9, + exclusiveSet: _witList14, + }; + + _option16 = Option!(CustomEnchantment).makeSome(_record15); + } else { + _option16 = Option!(CustomEnchantment).makeNone; + } + auto _flush17 = _option16; + return _flush17; + } + /// ditto + @wasmImport!("pumpkin:plugin/enchantments@0.1.0", "[method]enchantment-manager.get-enchantment") + pragma(mangle, "__wit_import_pumpkin:plugin__enchantments@0.1.0__:method:enchantment_manager.get_enchantment") + static private extern(C) void __import_getEnchantment(uint, void*, size_t, void*) nothrow; + + /++ + Checks if an enchantment ID is registered. + +/ + bool hasEnchantment(in WitString id) @trusted nothrow { + auto _ret = __import_hasEnchantment(this.__handle, cast(void*)(id.ptr), id.length); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/enchantments@0.1.0", "[method]enchantment-manager.has-enchantment") + pragma(mangle, "__wit_import_pumpkin:plugin__enchantments@0.1.0__:method:enchantment_manager.has_enchantment") + static private extern(C) uint __import_hasEnchantment(uint, void*, size_t) nothrow; + + /++ + Returns all registered custom enchantment IDs. + +/ + WitList!(WitString) getAllEnchantmentIds() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getAllEnchantmentIds(this.__handle, _retArea.ptr); + auto _listSrcPtr3 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen3 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list3 = _listLen3 ? wit.common.mallocSlice!(WitString)(_listLen3) : []; + assert(!_listLen3 || _list3.ptr); + foreach (_elem0_idx, ref _elem0; _list3) { + const auto _base0 = _listSrcPtr3 + _elem0_idx * (2*size_t.sizeof); + auto _len1 = *(cast(size_t*)(_base0 + size_t.sizeof)); + auto _ptr1 = _len1 ? cast(char*)(*(cast(void**)(_base0 + 0))) : null; + auto _list2 = WitString(_ptr1[0.._len1]); + _elem0 = _list2; + } + if (_listLen3) wit.common.free(_listSrcPtr3); + auto _witList4 = WitList!(WitString)(_list3); + auto _flush5 = _witList4; + return _flush5; + } + /// ditto + @wasmImport!("pumpkin:plugin/enchantments@0.1.0", "[method]enchantment-manager.get-all-enchantment-ids") + pragma(mangle, "__wit_import_pumpkin:plugin__enchantments@0.1.0__:method:enchantment_manager.get_all_enchantment_ids") + static private extern(C) void __import_getAllEnchantmentIds(uint, void*) nothrow; + } +} diff --git a/src/wit/pumpkin/plugin/entity/common.d b/src/wit/pumpkin/plugin/entity/common.d new file mode 100644 index 0000000..89449db --- /dev/null +++ b/src/wit/pumpkin/plugin/entity/common.d @@ -0,0 +1,106 @@ +/++ + ++/ +module wit.pumpkin.plugin.entity.common; + + +import wit.common; + +static import wit.pumpkin.plugin.world.common; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias PathNodeType = wit.pumpkin.plugin.world.common.PathNodeType; + +/++ + ++/ +alias DyeColor = wit.pumpkin.plugin.world.common.DyeColor; + +/++ + ++/ +alias VillagerProfession = wit.pumpkin.plugin.world.common.VillagerProfession; + +/++ + ++/ +alias MobData = wit.pumpkin.plugin.world.common.MobData; + +/++ + ++/ +alias SheepData = wit.pumpkin.plugin.world.common.SheepData; + +/++ + ++/ +alias WolfData = wit.pumpkin.plugin.world.common.WolfData; + +/++ + ++/ +alias CatData = wit.pumpkin.plugin.world.common.CatData; + +/++ + ++/ +alias VillagerData = wit.pumpkin.plugin.world.common.VillagerData; + +/++ + ++/ +alias CreeperData = wit.pumpkin.plugin.world.common.CreeperData; + +/++ + ++/ +alias SlimeData = wit.pumpkin.plugin.world.common.SlimeData; + +/++ + ++/ +alias EndermanData = wit.pumpkin.plugin.world.common.EndermanData; + +/++ + ++/ +alias IronGolemData = wit.pumpkin.plugin.world.common.IronGolemData; + +/++ + ++/ +alias FoxData = wit.pumpkin.plugin.world.common.FoxData; + +/++ + ++/ +alias AgeableData = wit.pumpkin.plugin.world.common.AgeableData; + +/++ + ++/ +alias ZombieData = wit.pumpkin.plugin.world.common.ZombieData; + +/++ + ++/ +alias ShulkerData = wit.pumpkin.plugin.world.common.ShulkerData; + +/++ + ++/ +alias RaycastResult = wit.pumpkin.plugin.world.common.RaycastResult; + +/++ + ++/ +alias RayTraceBlockResult = wit.pumpkin.plugin.world.common.RayTraceBlockResult; + +/++ + ++/ +alias BlockDirection = wit.pumpkin.plugin.world.common.BlockDirection; diff --git a/src/wit/pumpkin/plugin/entity/imports.d b/src/wit/pumpkin/plugin/entity/imports.d new file mode 100644 index 0000000..0a03dcf --- /dev/null +++ b/src/wit/pumpkin/plugin/entity/imports.d @@ -0,0 +1,33 @@ +/++ + ++/ +module wit.pumpkin.plugin.entity.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.entity.common; + +static import wit.pumpkin.plugin.world.imports; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias Entity = wit.pumpkin.plugin.world.imports.Entity; + +/++ + ++/ +alias LivingEntity = wit.pumpkin.plugin.world.imports.LivingEntity; + +/++ + ++/ +alias Mob = wit.pumpkin.plugin.world.imports.Mob; + +/++ + ++/ +alias RayTraceEntityResult = wit.pumpkin.plugin.world.imports.RayTraceEntityResult; diff --git a/src/wit/pumpkin/plugin/entity_statuses/common.d b/src/wit/pumpkin/plugin/entity_statuses/common.d new file mode 100644 index 0000000..fe7c9e8 --- /dev/null +++ b/src/wit/pumpkin/plugin/entity_statuses/common.d @@ -0,0 +1,325 @@ +/++ + ++/ +module wit.pumpkin.plugin.entity_statuses.common; + + +import wit.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +enum EntityStatus : ubyte { + /++ + + +/ + armadilloPeek, + + /++ + + +/ + armorstandWobble, + + /++ + + +/ + bodyBreak, + + /++ + + +/ + cancelShakeWetness, + + /++ + + +/ + chestBreak, + + /++ + + +/ + death, + + /++ + + +/ + dolphinLookingForTreasure, + + /++ + + +/ + drownParticles, + + /++ + + +/ + eatGrass, + + /++ + + +/ + endRam, + + /++ + + +/ + feetBreak, + + /++ + + +/ + fireworksExplode, + + /++ + + +/ + fishingRodReelIn, + + /++ + + +/ + foxEat, + + /++ + + +/ + fullDebugInfo, + + /++ + + +/ + guardianAttackSound, + + /++ + + +/ + headBreak, + + /++ + + +/ + honeyJump, + + /++ + + +/ + honeySlide, + + /++ + + +/ + inLoveHearts, + + /++ + + +/ + jump, + + /++ + + +/ + kineticHit, + + /++ + + +/ + legsBreak, + + /++ + + +/ + loveHearts, + + /++ + + +/ + mainhandBreak, + + /++ + + +/ + offerFlower, + + /++ + + +/ + offhandBreak, + + /++ + + +/ + permissionLevelAdmins, + + /++ + + +/ + permissionLevelAll, + + /++ + + +/ + permissionLevelGamemasters, + + /++ + + +/ + permissionLevelModerators, + + /++ + + +/ + permissionLevelOwners, + + /++ + + +/ + poof, + + /++ + + +/ + protectedFromDeath, + + /++ + + +/ + ravagerRoared, + + /++ + + +/ + ravagerStunned, + + /++ + + +/ + reducedDebugInfo, + + /++ + + +/ + saddleBreak, + + /++ + + +/ + shake, + + /++ + + +/ + shakeWetness, + + /++ + + +/ + silverfishMergeAnim, + + /++ + + +/ + snifferDiggingSound, + + /++ + + +/ + sonicCharge, + + /++ + + +/ + squidAnimSynch, + + /++ + + +/ + startAttacking, + + /++ + + +/ + startRam, + + /++ + + +/ + stopAttacking, + + /++ + + +/ + stopOfferFlower, + + /++ + + +/ + swapHands, + + /++ + + +/ + tamingFailed, + + /++ + + +/ + tamingSucceeded, + + /++ + + +/ + teleport, + + /++ + + +/ + tendrilsShiver, + + /++ + + +/ + tntPrime, + + /++ + + +/ + trustingFailed, + + /++ + + +/ + trustingSucceeded, + + /++ + + +/ + useItemComplete, + + /++ + + +/ + villagerAngry, + + /++ + + +/ + villagerHappy, + + /++ + + +/ + villagerSweat, + + /++ + + +/ + witchHatMagic, + + /++ + + +/ + zombieConverting, +} \ No newline at end of file diff --git a/src/wit/pumpkin/plugin/entity_statuses/imports.d b/src/wit/pumpkin/plugin/entity_statuses/imports.d new file mode 100644 index 0000000..5eca105 --- /dev/null +++ b/src/wit/pumpkin/plugin/entity_statuses/imports.d @@ -0,0 +1,12 @@ +/++ + ++/ +module wit.pumpkin.plugin.entity_statuses.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.entity_statuses.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); diff --git a/src/wit/pumpkin/plugin/entity_types/common.d b/src/wit/pumpkin/plugin/entity_types/common.d new file mode 100644 index 0000000..f15cd9e --- /dev/null +++ b/src/wit/pumpkin/plugin/entity_types/common.d @@ -0,0 +1,805 @@ +/++ + ++/ +module wit.pumpkin.plugin.entity_types.common; + + +import wit.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +enum EntityType : ubyte { + /++ + + +/ + acaciaBoat, + + /++ + + +/ + acaciaChestBoat, + + /++ + + +/ + allay, + + /++ + + +/ + areaEffectCloud, + + /++ + + +/ + armadillo, + + /++ + + +/ + armorStand, + + /++ + + +/ + arrow, + + /++ + + +/ + axolotl, + + /++ + + +/ + bambooChestRaft, + + /++ + + +/ + bambooRaft, + + /++ + + +/ + bat, + + /++ + + +/ + bee, + + /++ + + +/ + birchBoat, + + /++ + + +/ + birchChestBoat, + + /++ + + +/ + blaze, + + /++ + + +/ + blockDisplay, + + /++ + + +/ + bogged, + + /++ + + +/ + breeze, + + /++ + + +/ + breezeWindCharge, + + /++ + + +/ + camel, + + /++ + + +/ + camelHusk, + + /++ + + +/ + cat, + + /++ + + +/ + caveSpider, + + /++ + + +/ + cherryBoat, + + /++ + + +/ + cherryChestBoat, + + /++ + + +/ + chestMinecart, + + /++ + + +/ + chicken, + + /++ + + +/ + cod, + + /++ + + +/ + commandBlockMinecart, + + /++ + + +/ + copperGolem, + + /++ + + +/ + cow, + + /++ + + +/ + creaking, + + /++ + + +/ + creeper, + + /++ + + +/ + darkOakBoat, + + /++ + + +/ + darkOakChestBoat, + + /++ + + +/ + dolphin, + + /++ + + +/ + donkey, + + /++ + + +/ + dragonFireball, + + /++ + + +/ + drowned, + + /++ + + +/ + egg, + + /++ + + +/ + elderGuardian, + + /++ + + +/ + endCrystal, + + /++ + + +/ + enderDragon, + + /++ + + +/ + enderPearl, + + /++ + + +/ + enderman, + + /++ + + +/ + endermite, + + /++ + + +/ + evoker, + + /++ + + +/ + evokerFangs, + + /++ + + +/ + experienceBottle, + + /++ + + +/ + experienceOrb, + + /++ + + +/ + eyeOfEnder, + + /++ + + +/ + fallingBlock, + + /++ + + +/ + fireball, + + /++ + + +/ + fireworkRocket, + + /++ + + +/ + fishingBobber, + + /++ + + +/ + fox, + + /++ + + +/ + frog, + + /++ + + +/ + furnaceMinecart, + + /++ + + +/ + ghast, + + /++ + + +/ + giant, + + /++ + + +/ + glowItemFrame, + + /++ + + +/ + glowSquid, + + /++ + + +/ + goat, + + /++ + + +/ + guardian, + + /++ + + +/ + happyGhast, + + /++ + + +/ + hoglin, + + /++ + + +/ + hopperMinecart, + + /++ + + +/ + horse, + + /++ + + +/ + husk, + + /++ + + +/ + illusioner, + + /++ + + +/ + interaction, + + /++ + + +/ + ironGolem, + + /++ + + +/ + item, + + /++ + + +/ + itemDisplay, + + /++ + + +/ + itemFrame, + + /++ + + +/ + jungleBoat, + + /++ + + +/ + jungleChestBoat, + + /++ + + +/ + leashKnot, + + /++ + + +/ + lightningBolt, + + /++ + + +/ + lingeringPotion, + + /++ + + +/ + llama, + + /++ + + +/ + llamaSpit, + + /++ + + +/ + magmaCube, + + /++ + + +/ + mangroveBoat, + + /++ + + +/ + mangroveChestBoat, + + /++ + + +/ + mannequin, + + /++ + + +/ + marker, + + /++ + + +/ + minecart, + + /++ + + +/ + mooshroom, + + /++ + + +/ + mule, + + /++ + + +/ + nautilus, + + /++ + + +/ + oakBoat, + + /++ + + +/ + oakChestBoat, + + /++ + + +/ + ocelot, + + /++ + + +/ + ominousItemSpawner, + + /++ + + +/ + painting, + + /++ + + +/ + paleOakBoat, + + /++ + + +/ + paleOakChestBoat, + + /++ + + +/ + panda, + + /++ + + +/ + parched, + + /++ + + +/ + parrot, + + /++ + + +/ + phantom, + + /++ + + +/ + pig, + + /++ + + +/ + piglin, + + /++ + + +/ + piglinBrute, + + /++ + + +/ + pillager, + + /++ + + +/ + player, + + /++ + + +/ + polarBear, + + /++ + + +/ + pufferfish, + + /++ + + +/ + rabbit, + + /++ + + +/ + ravager, + + /++ + + +/ + salmon, + + /++ + + +/ + sheep, + + /++ + + +/ + shulker, + + /++ + + +/ + shulkerBullet, + + /++ + + +/ + silverfish, + + /++ + + +/ + skeleton, + + /++ + + +/ + skeletonHorse, + + /++ + + +/ + slime, + + /++ + + +/ + smallFireball, + + /++ + + +/ + sniffer, + + /++ + + +/ + snowGolem, + + /++ + + +/ + snowball, + + /++ + + +/ + spawnerMinecart, + + /++ + + +/ + spectralArrow, + + /++ + + +/ + spider, + + /++ + + +/ + splashPotion, + + /++ + + +/ + spruceBoat, + + /++ + + +/ + spruceChestBoat, + + /++ + + +/ + squid, + + /++ + + +/ + stray, + + /++ + + +/ + strider, + + /++ + + +/ + sulfurCube, + + /++ + + +/ + tadpole, + + /++ + + +/ + textDisplay, + + /++ + + +/ + tnt, + + /++ + + +/ + tntMinecart, + + /++ + + +/ + traderLlama, + + /++ + + +/ + trident, + + /++ + + +/ + tropicalFish, + + /++ + + +/ + turtle, + + /++ + + +/ + vex, + + /++ + + +/ + villager, + + /++ + + +/ + vindicator, + + /++ + + +/ + wanderingTrader, + + /++ + + +/ + warden, + + /++ + + +/ + windCharge, + + /++ + + +/ + witch, + + /++ + + +/ + wither, + + /++ + + +/ + witherSkeleton, + + /++ + + +/ + witherSkull, + + /++ + + +/ + wolf, + + /++ + + +/ + zoglin, + + /++ + + +/ + zombie, + + /++ + + +/ + zombieHorse, + + /++ + + +/ + zombieNautilus, + + /++ + + +/ + zombieVillager, + + /++ + + +/ + zombifiedPiglin, +} \ No newline at end of file diff --git a/src/wit/pumpkin/plugin/entity_types/imports.d b/src/wit/pumpkin/plugin/entity_types/imports.d new file mode 100644 index 0000000..3ca37db --- /dev/null +++ b/src/wit/pumpkin/plugin/entity_types/imports.d @@ -0,0 +1,12 @@ +/++ + ++/ +module wit.pumpkin.plugin.entity_types.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.entity_types.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); diff --git a/src/wit/pumpkin/plugin/event/common.d b/src/wit/pumpkin/plugin/event/common.d new file mode 100644 index 0000000..4b23942 --- /dev/null +++ b/src/wit/pumpkin/plugin/event/common.d @@ -0,0 +1,6339 @@ +/++ + ++/ +module wit.pumpkin.plugin.event.common; + + +import wit.common; + +static import wit.pumpkin.plugin.common.common; +static import wit.pumpkin.plugin.damage_types.common; +static import wit.pumpkin.plugin.screens.common; +static import wit.pumpkin.plugin.text.common; +static import wit.pumpkin.plugin.enchantments.common; +static import wit.pumpkin.plugin.item_stack.common; +static import wit.pumpkin.plugin.java_dialogs.common; +static import wit.pumpkin.plugin.uuid.common; +static import wit.pumpkin.plugin.bedrock_packets.common; +static import wit.pumpkin.plugin.java_packets.common; +static import wit.pumpkin.plugin.world.common; +static import wit.pumpkin.plugin.player.common; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias BlockPos = wit.pumpkin.plugin.common.common.BlockPos; + +/++ + ++/ +alias GameMode = wit.pumpkin.plugin.common.common.GameMode; + +/++ + ++/ +alias Hand = wit.pumpkin.plugin.common.common.Hand; + +/++ + ++/ +alias Position = wit.pumpkin.plugin.common.common.Position; + +/++ + ++/ +alias ClickType = wit.pumpkin.plugin.common.common.ClickType; + +/++ + ++/ +alias Enchantment = wit.pumpkin.plugin.enchantments.common.Enchantment; + +/++ + ++/ +alias DamageType = wit.pumpkin.plugin.damage_types.common.DamageType; + +/++ + ++/ +alias Screen = wit.pumpkin.plugin.screens.common.Screen; + +/++ + ++/ +alias JavaServerboundPacket = wit.pumpkin.plugin.java_packets.common.ServerboundPacket; + +/++ + ++/ +alias JavaClientboundPacket = wit.pumpkin.plugin.java_packets.common.ClientboundPacket; + +/++ + ++/ +alias BedrockServerboundPacket = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket; + +/++ + ++/ +alias BedrockClientboundPacket = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket; + +/++ + ++/ +alias Uuid = wit.pumpkin.plugin.uuid.common.Uuid; + +/++ + ++/ +struct ServerboundPacket { + mixin WitVariant!( + JavaServerboundPacket, // java + BedrockServerboundPacket, // bedrock + void, // unknown + ); + +public: + enum Tag : ubyte { + /++ + + +/ + java, + + /++ + + +/ + bedrock, + + /++ + + +/ + unknown, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias java = _create!(Tag.java); + /// ditto + pragma(inline, true) bool isJava() const => _tag == Tag.java; + ///ditto + alias getJava = _get!(Tag.java); + + /++ + + +/ + alias bedrock = _create!(Tag.bedrock); + /// ditto + pragma(inline, true) bool isBedrock() const => _tag == Tag.bedrock; + ///ditto + alias getBedrock = _get!(Tag.bedrock); + + /++ + + +/ + alias unknown = _create!(Tag.unknown); + /// ditto + pragma(inline, true) bool isUnknown() const => _tag == Tag.unknown; + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case java: _get!(Tag.java).witFree; break; + case bedrock: _get!(Tag.bedrock).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + } + + ServerboundPacket witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.java: return _create!(Tag.java)(this._get!(Tag.java).witClone); break; + case Tag.bedrock: return _create!(Tag.bedrock)(this._get!(Tag.bedrock).witClone); break; + case Tag.unknown: return _create!(Tag.unknown); break; + } + } +} + +/++ + ++/ +struct ClientboundPacket { + mixin WitVariant!( + JavaClientboundPacket, // java + BedrockClientboundPacket, // bedrock + void, // unknown + ); + +public: + enum Tag : ubyte { + /++ + + +/ + java, + + /++ + + +/ + bedrock, + + /++ + + +/ + unknown, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias java = _create!(Tag.java); + /// ditto + pragma(inline, true) bool isJava() const => _tag == Tag.java; + ///ditto + alias getJava = _get!(Tag.java); + + /++ + + +/ + alias bedrock = _create!(Tag.bedrock); + /// ditto + pragma(inline, true) bool isBedrock() const => _tag == Tag.bedrock; + ///ditto + alias getBedrock = _get!(Tag.bedrock); + + /++ + + +/ + alias unknown = _create!(Tag.unknown); + /// ditto + pragma(inline, true) bool isUnknown() const => _tag == Tag.unknown; + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case java: _get!(Tag.java).witFree; break; + case bedrock: _get!(Tag.bedrock).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + } + + ClientboundPacket witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.java: return _create!(Tag.java)(this._get!(Tag.java).witClone); break; + case Tag.bedrock: return _create!(Tag.bedrock)(this._get!(Tag.bedrock).witClone); break; + case Tag.unknown: return _create!(Tag.unknown); break; + } + } +} + +/++ + ++/ +enum EventPriority : ubyte { + /++ + + +/ + highest, + + /++ + + +/ + high, + + /++ + + +/ + normal, + + /++ + + +/ + low, + + /++ + + +/ + lowest, +} +/++ + ++/ +enum PlayerFishState : ubyte { + /++ + + +/ + fishing, + + /++ + + +/ + caughtFish, + + /++ + + +/ + caughtEntity, + + /++ + + +/ + inGround, + + /++ + + +/ + failedAttempt, + + /++ + + +/ + reelIn, + + /++ + + +/ + bite, +} +/++ + ++/ +enum EntityInteractionAction : ubyte { + /++ + + +/ + interact, + + /++ + + +/ + attack, + + /++ + + +/ + interactAt, +} +/++ + ++/ +enum InteractAction : ubyte { + /++ + + +/ + leftClickBlock, + + /++ + + +/ + leftClickAir, + + /++ + + +/ + rightClickAir, + + /++ + + +/ + rightClickBlock, +} +/++ + ++/ +struct BlockBurnEventData { + /++ + + +/ + WitString ignitingBlock; + + /++ + + +/ + WitString block; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + ignitingBlock.witFree; + block.witFree; + } + + void witDrop() @nogc nothrow { + } + + BlockBurnEventData witClone() const @nogc nothrow { + BlockBurnEventData clone = void; + clone.ignitingBlock = this.ignitingBlock.witClone; + clone.block = this.block.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct ServerCommandEventData { + /++ + + +/ + WitString command; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + command.witFree; + } + + void witDrop() @nogc nothrow { + } + + ServerCommandEventData witClone() const @nogc nothrow { + ServerCommandEventData clone = void; + clone.command = this.command.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct ServerListPingAddress { + /++ + + +/ + WitString host; + + /++ + + +/ + ushort port; + + void witFree() @nogc nothrow { + host.witFree; + } + + void witDrop() @nogc nothrow { + } + + ServerListPingAddress witClone() const @nogc nothrow { + ServerListPingAddress clone = void; + clone.host = this.host.witClone; + clone.port = this.port.witClone; + return clone; + } +} + +/++ + ++/ +enum ServerLoadType : ubyte { + /++ + + +/ + startup, + + /++ + + +/ + reload, +} +/++ + ++/ +struct ServerLoadEventData { + /++ + + +/ + ServerLoadType loadType; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ServerLoadEventData witClone() const @nogc nothrow { + ServerLoadEventData clone = void; + clone.loadType = this.loadType.witClone; + return clone; + } +} + +/++ + ++/ +struct ServerTickStartEventData { + /++ + + +/ + int tick; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ServerTickStartEventData witClone() const @nogc nothrow { + ServerTickStartEventData clone = void; + clone.tick = this.tick.witClone; + return clone; + } +} + +/++ + ++/ +struct ServerTickEndEventData { + /++ + + +/ + int tick; + + /++ + + +/ + long durationNanos; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ServerTickEndEventData witClone() const @nogc nothrow { + ServerTickEndEventData clone = void; + clone.tick = this.tick.witClone; + clone.durationNanos = this.durationNanos.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityDamageEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + float damage; + + /++ + + +/ + DamageType damageType; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityDamageEventData witClone() const @nogc nothrow { + EntityDamageEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.damage = this.damage.witClone; + clone.damageType = this.damageType.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityDeathEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + int droppedExp; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityDeathEventData witClone() const @nogc nothrow { + EntityDeathEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.droppedExp = this.droppedExp.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityCombustEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + float durationSecs; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityCombustEventData witClone() const @nogc nothrow { + EntityCombustEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.durationSecs = this.durationSecs.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityRegainHealthEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + float amount; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityRegainHealthEventData witClone() const @nogc nothrow { + EntityRegainHealthEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.amount = this.amount.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityAirChangeEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + int amount; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityAirChangeEventData witClone() const @nogc nothrow { + EntityAirChangeEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.amount = this.amount.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityBreedEventData { + /++ + + +/ + int fatherId; + + /++ + + +/ + int motherId; + + /++ + + +/ + int childId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityBreedEventData witClone() const @nogc nothrow { + EntityBreedEventData clone = void; + clone.fatherId = this.fatherId.witClone; + clone.motherId = this.motherId.witClone; + clone.childId = this.childId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityDismountEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + int dismountedId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityDismountEventData witClone() const @nogc nothrow { + EntityDismountEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.dismountedId = this.dismountedId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityEnterLoveModeEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + Option!(int) humanEntityId; + + /++ + + +/ + int ticksInLove; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityEnterLoveModeEventData witClone() const @nogc nothrow { + EntityEnterLoveModeEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.humanEntityId = this.humanEntityId.witClone; + clone.ticksInLove = this.ticksInLove.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityExplodeEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + Position position; + + /++ + + +/ + float yieldRate; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityExplodeEventData witClone() const @nogc nothrow { + EntityExplodeEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.position = this.position.witClone; + clone.yieldRate = this.yieldRate.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityMountEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + int mountedId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityMountEventData witClone() const @nogc nothrow { + EntityMountEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.mountedId = this.mountedId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityPickupItemEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + WitString itemName; + + /++ + + +/ + ubyte count; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + itemName.witFree; + } + + void witDrop() @nogc nothrow { + } + + EntityPickupItemEventData witClone() const @nogc nothrow { + EntityPickupItemEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.itemName = this.itemName.witClone; + clone.count = this.count.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityPortalEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + BlockPos portalPos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityPortalEventData witClone() const @nogc nothrow { + EntityPortalEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.portalPos = this.portalPos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityResurrectEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityResurrectEventData witClone() const @nogc nothrow { + EntityResurrectEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityShootBowEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + WitString weaponName; + + /++ + + +/ + float force; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + weaponName.witFree; + } + + void witDrop() @nogc nothrow { + } + + EntityShootBowEventData witClone() const @nogc nothrow { + EntityShootBowEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.weaponName = this.weaponName.witClone; + clone.force = this.force.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityTargetEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + Option!(int) targetId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityTargetEventData witClone() const @nogc nothrow { + EntityTargetEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.targetId = this.targetId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityTeleportEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + Position fromPosition; + + /++ + + +/ + Position toPosition; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityTeleportEventData witClone() const @nogc nothrow { + EntityTeleportEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.fromPosition = this.fromPosition.witClone; + clone.toPosition = this.toPosition.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityToggleGlideEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + bool isGliding; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityToggleGlideEventData witClone() const @nogc nothrow { + EntityToggleGlideEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.isGliding = this.isGliding.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityTransformEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + int newEntityId; + + /++ + + +/ + WitString transformReason; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + transformReason.witFree; + } + + void witDrop() @nogc nothrow { + } + + EntityTransformEventData witClone() const @nogc nothrow { + EntityTransformEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.newEntityId = this.newEntityId.witClone; + clone.transformReason = this.transformReason.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EnderDragonChangePhaseEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + WitString currentPhase; + + /++ + + +/ + WitString newPhase; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + currentPhase.witFree; + newPhase.witFree; + } + + void witDrop() @nogc nothrow { + } + + EnderDragonChangePhaseEventData witClone() const @nogc nothrow { + EnderDragonChangePhaseEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.currentPhase = this.currentPhase.witClone; + clone.newPhase = this.newPhase.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityBreakDoorEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityBreakDoorEventData witClone() const @nogc nothrow { + EntityBreakDoorEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.blockPos = this.blockPos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityChangeBlockEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + WitString newBlock; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + newBlock.witFree; + } + + void witDrop() @nogc nothrow { + } + + EntityChangeBlockEventData witClone() const @nogc nothrow { + EntityChangeBlockEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.blockPos = this.blockPos.witClone; + clone.newBlock = this.newBlock.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityDamageByBlockEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + Option!(BlockPos) damagerPos; + + /++ + + +/ + float damage; + + /++ + + +/ + WitString cause; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + cause.witFree; + } + + void witDrop() @nogc nothrow { + } + + EntityDamageByBlockEventData witClone() const @nogc nothrow { + EntityDamageByBlockEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.damagerPos = this.damagerPos.witClone; + clone.damage = this.damage.witClone; + clone.cause = this.cause.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityDamageByEntityEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + int damagerId; + + /++ + + +/ + float damage; + + /++ + + +/ + WitString cause; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + cause.witFree; + } + + void witDrop() @nogc nothrow { + } + + EntityDamageByEntityEventData witClone() const @nogc nothrow { + EntityDamageByEntityEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.damagerId = this.damagerId.witClone; + clone.damage = this.damage.witClone; + clone.cause = this.cause.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityDropItemEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + WitString itemName; + + /++ + + +/ + ubyte count; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + itemName.witFree; + } + + void witDrop() @nogc nothrow { + } + + EntityDropItemEventData witClone() const @nogc nothrow { + EntityDropItemEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.itemName = this.itemName.witClone; + clone.count = this.count.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityEnterBlockEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityEnterBlockEventData witClone() const @nogc nothrow { + EntityEnterBlockEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.blockPos = this.blockPos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityExhaustionEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + float exhaustion; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityExhaustionEventData witClone() const @nogc nothrow { + EntityExhaustionEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.exhaustion = this.exhaustion.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityInteractEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityInteractEventData witClone() const @nogc nothrow { + EntityInteractEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.blockPos = this.blockPos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityKnockbackEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + Option!(int) hitById; + + /++ + + +/ + Position knockback; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityKnockbackEventData witClone() const @nogc nothrow { + EntityKnockbackEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.hitById = this.hitById.witClone; + clone.knockback = this.knockback.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityPlaceEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + WitString blockName; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + blockName.witFree; + } + + void witDrop() @nogc nothrow { + } + + EntityPlaceEventData witClone() const @nogc nothrow { + EntityPlaceEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.blockPos = this.blockPos.witClone; + clone.blockName = this.blockName.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityPoseChangeEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + WitString pose; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + pose.witFree; + } + + void witDrop() @nogc nothrow { + } + + EntityPoseChangeEventData witClone() const @nogc nothrow { + EntityPoseChangeEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.pose = this.pose.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityPotionEffectEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + WitString effectName; + + /++ + + +/ + int duration; + + /++ + + +/ + ubyte amplifier; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + effectName.witFree; + } + + void witDrop() @nogc nothrow { + } + + EntityPotionEffectEventData witClone() const @nogc nothrow { + EntityPotionEffectEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.effectName = this.effectName.witClone; + clone.duration = this.duration.witClone; + clone.amplifier = this.amplifier.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntitySpellCastEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + WitString spell; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + spell.witFree; + } + + void witDrop() @nogc nothrow { + } + + EntitySpellCastEventData witClone() const @nogc nothrow { + EntitySpellCastEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.spell = this.spell.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityTargetLivingEntityEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + Option!(int) targetId; + + /++ + + +/ + WitString reason; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + reason.witFree; + } + + void witDrop() @nogc nothrow { + } + + EntityTargetLivingEntityEventData witClone() const @nogc nothrow { + EntityTargetLivingEntityEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.targetId = this.targetId.witClone; + clone.reason = this.reason.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityToggleSwimEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + bool isSwimming; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityToggleSwimEventData witClone() const @nogc nothrow { + EntityToggleSwimEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.isSwimming = this.isSwimming.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct ExplosionPrimeEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + float radius; + + /++ + + +/ + bool fire; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ExplosionPrimeEventData witClone() const @nogc nothrow { + ExplosionPrimeEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.radius = this.radius.witClone; + clone.fire = this.fire.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct FireworkExplodeEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + FireworkExplodeEventData witClone() const @nogc nothrow { + FireworkExplodeEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct FoodLevelChangeEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + ubyte foodLevel; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + FoodLevelChangeEventData witClone() const @nogc nothrow { + FoodLevelChangeEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.foodLevel = this.foodLevel.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemDespawnEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ItemDespawnEventData witClone() const @nogc nothrow { + ItemDespawnEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemMergeEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + int targetId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ItemMergeEventData witClone() const @nogc nothrow { + ItemMergeEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.targetId = this.targetId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct ItemSpawnEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + Position position; + + /++ + + +/ + WitString itemName; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + itemName.witFree; + } + + void witDrop() @nogc nothrow { + } + + ItemSpawnEventData witClone() const @nogc nothrow { + ItemSpawnEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.position = this.position.witClone; + clone.itemName = this.itemName.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct ProjectileHitEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + Position hitPosition; + + /++ + + +/ + Option!(int) hitEntityId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ProjectileHitEventData witClone() const @nogc nothrow { + ProjectileHitEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.hitPosition = this.hitPosition.witClone; + clone.hitEntityId = this.hitEntityId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct ProjectileLaunchEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + Option!(int) shooterId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ProjectileLaunchEventData witClone() const @nogc nothrow { + ProjectileLaunchEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.shooterId = this.shooterId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct SheepDyeWoolEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + ubyte dyeColor; + + /++ + + +/ + Option!(int) playerId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SheepDyeWoolEventData witClone() const @nogc nothrow { + SheepDyeWoolEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.dyeColor = this.dyeColor.witClone; + clone.playerId = this.playerId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct SheepRegrowWoolEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SheepRegrowWoolEventData witClone() const @nogc nothrow { + SheepRegrowWoolEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct SlimeSplitEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + int count; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SlimeSplitEventData witClone() const @nogc nothrow { + SlimeSplitEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.count = this.count.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct StriderTemperatureChangeEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + bool isShivering; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + StriderTemperatureChangeEventData witClone() const @nogc nothrow { + StriderTemperatureChangeEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.isShivering = this.isShivering.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct VillagerAcquireTradeEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + int recipeIndex; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + VillagerAcquireTradeEventData witClone() const @nogc nothrow { + VillagerAcquireTradeEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.recipeIndex = this.recipeIndex.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct VillagerCareerChangeEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + WitString profession; + + /++ + + +/ + WitString reason; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + profession.witFree; + reason.witFree; + } + + void witDrop() @nogc nothrow { + } + + VillagerCareerChangeEventData witClone() const @nogc nothrow { + VillagerCareerChangeEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.profession = this.profession.witClone; + clone.reason = this.reason.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct VillagerReplenishTradeEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + int restockQuantity; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + VillagerReplenishTradeEventData witClone() const @nogc nothrow { + VillagerReplenishTradeEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.restockQuantity = this.restockQuantity.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct WardenAngerChangeEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + int targetId; + + /++ + + +/ + int oldAnger; + + /++ + + +/ + int newAnger; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + WardenAngerChangeEventData witClone() const @nogc nothrow { + WardenAngerChangeEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.targetId = this.targetId.witClone; + clone.oldAnger = this.oldAnger.witClone; + clone.newAnger = this.newAnger.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct AreaEffectCloudApplyEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + WitList!(int) affectedEntities; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + affectedEntities.witFree; + } + + void witDrop() @nogc nothrow { + } + + AreaEffectCloudApplyEventData witClone() const @nogc nothrow { + AreaEffectCloudApplyEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.affectedEntities = this.affectedEntities.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct ArrowBodyCountChangeEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + uint oldAmount; + + /++ + + +/ + uint newAmount; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ArrowBodyCountChangeEventData witClone() const @nogc nothrow { + ArrowBodyCountChangeEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.oldAmount = this.oldAmount.witClone; + clone.newAmount = this.newAmount.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BatToggleSleepEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + bool isAwake; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + BatToggleSleepEventData witClone() const @nogc nothrow { + BatToggleSleepEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.isAwake = this.isAwake.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct CreeperPowerEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + Option!(int) lightningId; + + /++ + + +/ + WitString cause; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + cause.witFree; + } + + void witDrop() @nogc nothrow { + } + + CreeperPowerEventData witClone() const @nogc nothrow { + CreeperPowerEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.lightningId = this.lightningId.witClone; + clone.cause = this.cause.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityCombustByBlockEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + BlockPos combuster; + + /++ + + +/ + float duration; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityCombustByBlockEventData witClone() const @nogc nothrow { + EntityCombustByBlockEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.combuster = this.combuster.witClone; + clone.duration = this.duration.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityCombustByEntityEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + int combusterId; + + /++ + + +/ + float duration; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityCombustByEntityEventData witClone() const @nogc nothrow { + EntityCombustByEntityEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.combusterId = this.combusterId.witClone; + clone.duration = this.duration.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityKnockbackByEntityEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + int hitById; + + /++ + + +/ + double force; + + /++ + + +/ + double x; + + /++ + + +/ + double z; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityKnockbackByEntityEventData witClone() const @nogc nothrow { + EntityKnockbackByEntityEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.hitById = this.hitById.witClone; + clone.force = this.force.witClone; + clone.x = this.x.witClone; + clone.z = this.z.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityPortalEnterEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + BlockPos location; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityPortalEnterEventData witClone() const @nogc nothrow { + EntityPortalEnterEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.location = this.location.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityPortalExitEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + BlockPos fromPos; + + /++ + + +/ + Option!(BlockPos) toPos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityPortalExitEventData witClone() const @nogc nothrow { + EntityPortalExitEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.fromPos = this.fromPos.witClone; + clone.toPos = this.toPos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityRemoveEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + WitString cause; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + cause.witFree; + } + + void witDrop() @nogc nothrow { + } + + EntityRemoveEventData witClone() const @nogc nothrow { + EntityRemoveEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.cause = this.cause.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityTargetBlockEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntityTargetBlockEventData witClone() const @nogc nothrow { + EntityTargetBlockEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.blockPos = this.blockPos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityUnleashEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + WitString reason; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + reason.witFree; + } + + void witDrop() @nogc nothrow { + } + + EntityUnleashEventData witClone() const @nogc nothrow { + EntityUnleashEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.reason = this.reason.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct ExpBottleEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + int experience; + + /++ + + +/ + BlockPos location; + + /++ + + +/ + bool showEffect; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ExpBottleEventData witClone() const @nogc nothrow { + ExpBottleEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.experience = this.experience.witClone; + clone.location = this.location.witClone; + clone.showEffect = this.showEffect.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct HorseJumpEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + float power; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + HorseJumpEventData witClone() const @nogc nothrow { + HorseJumpEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.power = this.power.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct LingeringPotionSplashEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + BlockPos location; + + /++ + + +/ + WitString potionItem; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + potionItem.witFree; + } + + void witDrop() @nogc nothrow { + } + + LingeringPotionSplashEventData witClone() const @nogc nothrow { + LingeringPotionSplashEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.location = this.location.witClone; + clone.potionItem = this.potionItem.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PigZapEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + int lightningId; + + /++ + + +/ + int pigZombieId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + PigZapEventData witClone() const @nogc nothrow { + PigZapEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.lightningId = this.lightningId.witClone; + clone.pigZombieId = this.pigZombieId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PigZombieAngerEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + Option!(int) targetId; + + /++ + + +/ + int newAnger; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + PigZombieAngerEventData witClone() const @nogc nothrow { + PigZombieAngerEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.targetId = this.targetId.witClone; + clone.newAnger = this.newAnger.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PotionSplashEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + BlockPos location; + + /++ + + +/ + WitString potionItem; + + /++ + + +/ + WitList!(int) affectedEntities; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + potionItem.witFree; + affectedEntities.witFree; + } + + void witDrop() @nogc nothrow { + } + + PotionSplashEventData witClone() const @nogc nothrow { + PotionSplashEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.location = this.location.witClone; + clone.potionItem = this.potionItem.witClone; + clone.affectedEntities = this.affectedEntities.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct SpawnerSpawnEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + BlockPos spawnerPos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SpawnerSpawnEventData witClone() const @nogc nothrow { + SpawnerSpawnEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.spawnerPos = this.spawnerPos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct TrialSpawnerSpawnEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + BlockPos spawnerPos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + TrialSpawnerSpawnEventData witClone() const @nogc nothrow { + TrialSpawnerSpawnEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.spawnerPos = this.spawnerPos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct VillagerReputationChangeEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + int targetId; + + /++ + + +/ + int reputationChange; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + VillagerReputationChangeEventData witClone() const @nogc nothrow { + VillagerReputationChangeEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.targetId = this.targetId.witClone; + clone.reputationChange = this.reputationChange.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct RaidFinishEventData { + /++ + + +/ + bool victory; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + RaidFinishEventData witClone() const @nogc nothrow { + RaidFinishEventData clone = void; + clone.victory = this.victory.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct RaidSpawnWaveEventData { + /++ + + +/ + uint wave; + + /++ + + +/ + BlockPos pos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + RaidSpawnWaveEventData witClone() const @nogc nothrow { + RaidSpawnWaveEventData clone = void; + clone.wave = this.wave.witClone; + clone.pos = this.pos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct RaidStopEventData { + /++ + + +/ + WitString reason; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + reason.witFree; + } + + void witDrop() @nogc nothrow { + } + + RaidStopEventData witClone() const @nogc nothrow { + RaidStopEventData clone = void; + clone.reason = this.reason.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct RaidTriggerEventData { + /++ + + +/ + BlockPos pos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + RaidTriggerEventData witClone() const @nogc nothrow { + RaidTriggerEventData clone = void; + clone.pos = this.pos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockIgniteEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + BlockIgniteEventData witClone() const @nogc nothrow { + BlockIgniteEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockFromToEventData { + /++ + + +/ + BlockPos fromPos; + + /++ + + +/ + BlockPos toPos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + BlockFromToEventData witClone() const @nogc nothrow { + BlockFromToEventData clone = void; + clone.fromPos = this.fromPos.witClone; + clone.toPos = this.toPos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockFormEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + BlockFormEventData witClone() const @nogc nothrow { + BlockFormEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockFadeEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + BlockFadeEventData witClone() const @nogc nothrow { + BlockFadeEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockDispenseEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + WitString itemName; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + itemName.witFree; + } + + void witDrop() @nogc nothrow { + } + + BlockDispenseEventData witClone() const @nogc nothrow { + BlockDispenseEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.itemName = this.itemName.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockExplodeEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + float yieldRate; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + BlockExplodeEventData witClone() const @nogc nothrow { + BlockExplodeEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.yieldRate = this.yieldRate.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockPhysicsEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + BlockPos changedPos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + BlockPhysicsEventData witClone() const @nogc nothrow { + BlockPhysicsEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.changedPos = this.changedPos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockPistonExtendEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + WitString direction; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + direction.witFree; + } + + void witDrop() @nogc nothrow { + } + + BlockPistonExtendEventData witClone() const @nogc nothrow { + BlockPistonExtendEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.direction = this.direction.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockPistonRetractEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + WitString direction; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + direction.witFree; + } + + void witDrop() @nogc nothrow { + } + + BlockPistonRetractEventData witClone() const @nogc nothrow { + BlockPistonRetractEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.direction = this.direction.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct NotePlayEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + WitString instrument; + + /++ + + +/ + ubyte note; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + instrument.witFree; + } + + void witDrop() @nogc nothrow { + } + + NotePlayEventData witClone() const @nogc nothrow { + NotePlayEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.instrument = this.instrument.witClone; + clone.note = this.note.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct SpongeAbsorbEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SpongeAbsorbEventData witClone() const @nogc nothrow { + SpongeAbsorbEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct TntPrimeEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + WitString primeReason; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + primeReason.witFree; + } + + void witDrop() @nogc nothrow { + } + + TntPrimeEventData witClone() const @nogc nothrow { + TntPrimeEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.primeReason = this.primeReason.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct MapInitializeEventData { + /++ + + +/ + int mapId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + MapInitializeEventData witClone() const @nogc nothrow { + MapInitializeEventData clone = void; + clone.mapId = this.mapId.witClone; + return clone; + } +} + +/++ + ++/ +struct HangingBreakEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + Option!(int) removerEntityId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + HangingBreakEventData witClone() const @nogc nothrow { + HangingBreakEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.removerEntityId = this.removerEntityId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct HangingBreakByEntityEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + int removerEntityId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + HangingBreakByEntityEventData witClone() const @nogc nothrow { + HangingBreakByEntityEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.removerEntityId = this.removerEntityId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct AsyncStructureGenerateEventData { + /++ + + +/ + WitString worldName; + + /++ + + +/ + WitString structureName; + + /++ + + +/ + BlockPos pos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + worldName.witFree; + structureName.witFree; + } + + void witDrop() @nogc nothrow { + } + + AsyncStructureGenerateEventData witClone() const @nogc nothrow { + AsyncStructureGenerateEventData clone = void; + clone.worldName = this.worldName.witClone; + clone.structureName = this.structureName.witClone; + clone.pos = this.pos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct AsyncStructureSpawnEventData { + /++ + + +/ + WitString worldName; + + /++ + + +/ + WitString structureName; + + /++ + + +/ + BlockPos pos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + worldName.witFree; + structureName.witFree; + } + + void witDrop() @nogc nothrow { + } + + AsyncStructureSpawnEventData witClone() const @nogc nothrow { + AsyncStructureSpawnEventData clone = void; + clone.worldName = this.worldName.witClone; + clone.structureName = this.structureName.witClone; + clone.pos = this.pos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct ChunkPopulateEventData { + /++ + + +/ + int chunkX; + + /++ + + +/ + int chunkZ; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ChunkPopulateEventData witClone() const @nogc nothrow { + ChunkPopulateEventData clone = void; + clone.chunkX = this.chunkX.witClone; + clone.chunkZ = this.chunkZ.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct ChunkUnloadEventData { + /++ + + +/ + int chunkX; + + /++ + + +/ + int chunkZ; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ChunkUnloadEventData witClone() const @nogc nothrow { + ChunkUnloadEventData clone = void; + clone.chunkX = this.chunkX.witClone; + clone.chunkZ = this.chunkZ.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntitiesLoadEventData { + /++ + + +/ + int chunkX; + + /++ + + +/ + int chunkZ; + + /++ + + +/ + uint entityCount; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntitiesLoadEventData witClone() const @nogc nothrow { + EntitiesLoadEventData clone = void; + clone.chunkX = this.chunkX.witClone; + clone.chunkZ = this.chunkZ.witClone; + clone.entityCount = this.entityCount.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntitiesUnloadEventData { + /++ + + +/ + int chunkX; + + /++ + + +/ + int chunkZ; + + /++ + + +/ + uint entityCount; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EntitiesUnloadEventData witClone() const @nogc nothrow { + EntitiesUnloadEventData clone = void; + clone.chunkX = this.chunkX.witClone; + clone.chunkZ = this.chunkZ.witClone; + clone.entityCount = this.entityCount.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct GenericGameEventData { + /++ + + +/ + WitString eventId; + + /++ + + +/ + Position pos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + eventId.witFree; + } + + void witDrop() @nogc nothrow { + } + + GenericGameEventData witClone() const @nogc nothrow { + GenericGameEventData clone = void; + clone.eventId = this.eventId.witClone; + clone.pos = this.pos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct LootGenerateEventData { + /++ + + +/ + WitString lootTable; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + lootTable.witFree; + } + + void witDrop() @nogc nothrow { + } + + LootGenerateEventData witClone() const @nogc nothrow { + LootGenerateEventData clone = void; + clone.lootTable = this.lootTable.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PortalCreateEventData { + /++ + + +/ + BlockPos pos; + + /++ + + +/ + WitString portalType; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + portalType.witFree; + } + + void witDrop() @nogc nothrow { + } + + PortalCreateEventData witClone() const @nogc nothrow { + PortalCreateEventData clone = void; + clone.pos = this.pos.witClone; + clone.portalType = this.portalType.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct StructureGrowEventData { + /++ + + +/ + BlockPos pos; + + /++ + + +/ + WitString species; + + /++ + + +/ + bool boneMeal; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + species.witFree; + } + + void witDrop() @nogc nothrow { + } + + StructureGrowEventData witClone() const @nogc nothrow { + StructureGrowEventData clone = void; + clone.pos = this.pos.witClone; + clone.species = this.species.witClone; + clone.boneMeal = this.boneMeal.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct TimeSkipEventData { + /++ + + +/ + long skipAmount; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + TimeSkipEventData witClone() const @nogc nothrow { + TimeSkipEventData clone = void; + clone.skipAmount = this.skipAmount.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct WorldSaveEventData { + /++ + + +/ + WitString worldName; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + worldName.witFree; + } + + void witDrop() @nogc nothrow { + } + + WorldSaveEventData witClone() const @nogc nothrow { + WorldSaveEventData clone = void; + clone.worldName = this.worldName.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct FurnaceSmeltEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + WitString sourceItem; + + /++ + + +/ + WitString resultItem; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + sourceItem.witFree; + resultItem.witFree; + } + + void witDrop() @nogc nothrow { + } + + FurnaceSmeltEventData witClone() const @nogc nothrow { + FurnaceSmeltEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.sourceItem = this.sourceItem.witClone; + clone.resultItem = this.resultItem.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BrewEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + ubyte fuelLevel; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + BrewEventData witClone() const @nogc nothrow { + BrewEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.fuelLevel = this.fuelLevel.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BrewingStandFuelEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + ushort fuelPower; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + BrewingStandFuelEventData witClone() const @nogc nothrow { + BrewingStandFuelEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.fuelPower = this.fuelPower.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct FurnaceBurnEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + WitString fuelItem; + + /++ + + +/ + uint burnTime; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + fuelItem.witFree; + } + + void witDrop() @nogc nothrow { + } + + FurnaceBurnEventData witClone() const @nogc nothrow { + FurnaceBurnEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.fuelItem = this.fuelItem.witClone; + clone.burnTime = this.burnTime.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct FurnaceStartSmeltEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + WitString sourceItem; + + /++ + + +/ + uint cookingTime; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + sourceItem.witFree; + } + + void witDrop() @nogc nothrow { + } + + FurnaceStartSmeltEventData witClone() const @nogc nothrow { + FurnaceStartSmeltEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.sourceItem = this.sourceItem.witClone; + clone.cookingTime = this.cookingTime.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct HopperInventorySearchEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + BlockPos searchPos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + HopperInventorySearchEventData witClone() const @nogc nothrow { + HopperInventorySearchEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.searchPos = this.searchPos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct InventoryMoveItemEventData { + /++ + + +/ + BlockPos sourcePos; + + /++ + + +/ + BlockPos targetPos; + + /++ + + +/ + WitString itemId; + + /++ + + +/ + uint itemAmount; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + itemId.witFree; + } + + void witDrop() @nogc nothrow { + } + + InventoryMoveItemEventData witClone() const @nogc nothrow { + InventoryMoveItemEventData clone = void; + clone.sourcePos = this.sourcePos.witClone; + clone.targetPos = this.targetPos.witClone; + clone.itemId = this.itemId.witClone; + clone.itemAmount = this.itemAmount.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct InventoryPickupItemEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + int itemEntityId; + + /++ + + +/ + WitString itemId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + itemId.witFree; + } + + void witDrop() @nogc nothrow { + } + + InventoryPickupItemEventData witClone() const @nogc nothrow { + InventoryPickupItemEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.itemEntityId = this.itemEntityId.witClone; + clone.itemId = this.itemId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct VehicleBlockCollisionEventData { + /++ + + +/ + int vehicleId; + + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + VehicleBlockCollisionEventData witClone() const @nogc nothrow { + VehicleBlockCollisionEventData clone = void; + clone.vehicleId = this.vehicleId.witClone; + clone.blockPos = this.blockPos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct VehicleCollisionEventData { + /++ + + +/ + int vehicleId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + VehicleCollisionEventData witClone() const @nogc nothrow { + VehicleCollisionEventData clone = void; + clone.vehicleId = this.vehicleId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct VehicleCreateEventData { + /++ + + +/ + int vehicleId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + VehicleCreateEventData witClone() const @nogc nothrow { + VehicleCreateEventData clone = void; + clone.vehicleId = this.vehicleId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct VehicleDamageEventData { + /++ + + +/ + int vehicleId; + + /++ + + +/ + float damage; + + /++ + + +/ + Option!(int) attackerId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + VehicleDamageEventData witClone() const @nogc nothrow { + VehicleDamageEventData clone = void; + clone.vehicleId = this.vehicleId.witClone; + clone.damage = this.damage.witClone; + clone.attackerId = this.attackerId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct VehicleDestroyEventData { + /++ + + +/ + int vehicleId; + + /++ + + +/ + Option!(int) attackerId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + VehicleDestroyEventData witClone() const @nogc nothrow { + VehicleDestroyEventData clone = void; + clone.vehicleId = this.vehicleId.witClone; + clone.attackerId = this.attackerId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct VehicleEnterEventData { + /++ + + +/ + int vehicleId; + + /++ + + +/ + int enteredId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + VehicleEnterEventData witClone() const @nogc nothrow { + VehicleEnterEventData clone = void; + clone.vehicleId = this.vehicleId.witClone; + clone.enteredId = this.enteredId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct VehicleEntityCollisionEventData { + /++ + + +/ + int vehicleId; + + /++ + + +/ + int collidedEntityId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + VehicleEntityCollisionEventData witClone() const @nogc nothrow { + VehicleEntityCollisionEventData clone = void; + clone.vehicleId = this.vehicleId.witClone; + clone.collidedEntityId = this.collidedEntityId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct VehicleExitEventData { + /++ + + +/ + int vehicleId; + + /++ + + +/ + int exitedId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + VehicleExitEventData witClone() const @nogc nothrow { + VehicleExitEventData clone = void; + clone.vehicleId = this.vehicleId.witClone; + clone.exitedId = this.exitedId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct VehicleMoveEventData { + /++ + + +/ + int vehicleId; + + /++ + + +/ + Position fromPosition; + + /++ + + +/ + Position toPosition; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + VehicleMoveEventData witClone() const @nogc nothrow { + VehicleMoveEventData clone = void; + clone.vehicleId = this.vehicleId.witClone; + clone.fromPosition = this.fromPosition.witClone; + clone.toPosition = this.toPosition.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct VehicleUpdateEventData { + /++ + + +/ + int vehicleId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + VehicleUpdateEventData witClone() const @nogc nothrow { + VehicleUpdateEventData clone = void; + clone.vehicleId = this.vehicleId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EnchantmentOffer { + /++ + + +/ + int cost; + + /++ + + +/ + int enchantmentId; + + /++ + + +/ + int enchantmentLevel; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EnchantmentOffer witClone() const @nogc nothrow { + EnchantmentOffer clone = void; + clone.cost = this.cost.witClone; + clone.enchantmentId = this.enchantmentId.witClone; + clone.enchantmentLevel = this.enchantmentLevel.witClone; + return clone; + } +} + +/++ + ++/ +struct EnchantmentValue { + /++ + + +/ + Enchantment enchantment; + + /++ + + +/ + uint level; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EnchantmentValue witClone() const @nogc nothrow { + EnchantmentValue clone = void; + clone.enchantment = this.enchantment.witClone; + clone.level = this.level.witClone; + return clone; + } +} + +/++ + ++/ +struct LightningStrikeEventData { + /++ + + +/ + Position position; + + /++ + + +/ + bool isEffect; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + LightningStrikeEventData witClone() const @nogc nothrow { + LightningStrikeEventData clone = void; + clone.position = this.position.witClone; + clone.isEffect = this.isEffect.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +enum EventType : ushort { + /++ + + +/ + playerJoinEvent, + + /++ + + +/ + playerLeaveEvent, + + /++ + + +/ + playerLoginEvent, + + /++ + + +/ + playerChatEvent, + + /++ + + +/ + playerCommandSendEvent, + + /++ + + +/ + playerPermissionCheckEvent, + + /++ + + +/ + playerMoveEvent, + + /++ + + +/ + playerTeleportEvent, + + /++ + + +/ + playerChangeWorldEvent, + + /++ + + +/ + playerRespawnEvent, + + /++ + + +/ + playerExpChangeEvent, + + /++ + + +/ + playerItemHeldEvent, + + /++ + + +/ + playerChangedMainHandEvent, + + /++ + + +/ + playerGamemodeChangeEvent, + + /++ + + +/ + playerCustomPayloadEvent, + + /++ + + +/ + playerFishEvent, + + /++ + + +/ + playerEggThrowEvent, + + /++ + + +/ + playerInteractUnknownEntityEvent, + + /++ + + +/ + playerInteractEntityEvent, + + /++ + + +/ + playerInteractEvent, + + /++ + + +/ + playerToggleSneakEvent, + + /++ + + +/ + playerToggleFlightEvent, + + /++ + + +/ + playerToggleSprintEvent, + + /++ + + +/ + inventoryClickEvent, + + /++ + + +/ + inventoryCloseEvent, + + /++ + + +/ + blockRedstoneEvent, + + /++ + + +/ + blockBreakEvent, + + /++ + + +/ + blockBurnEvent, + + /++ + + +/ + blockCanBuildEvent, + + /++ + + +/ + blockGrowEvent, + + /++ + + +/ + blockPlaceEvent, + + /++ + + +/ + bedrockFormResponseEvent, + + /++ + + +/ + dialogClickActionEvent, + + /++ + + +/ + dialogShowEvent, + + /++ + + +/ + dialogClearEvent, + + /++ + + +/ + serverCommandEvent, + + /++ + + +/ + serverListPingEvent, + + /++ + + +/ + serverLoadEvent, + + /++ + + +/ + spawnChangeEvent, + + /++ + + +/ + serverBroadcastEvent, + + /++ + + +/ + serverTickStartEvent, + + /++ + + +/ + serverTickEndEvent, + + /++ + + +/ + packetReceivedEvent, + + /++ + + +/ + packetSentEvent, + + /++ + + +/ + chunkLoadEvent, + + /++ + + +/ + chunkSaveEvent, + + /++ + + +/ + chunkSendEvent, + + /++ + + +/ + entityDamageEvent, + + /++ + + +/ + entityDeathEvent, + + /++ + + +/ + playerDeathEvent, + + /++ + + +/ + entitySpawnEvent, + + /++ + + +/ + entityCombustEvent, + + /++ + + +/ + entityRegainHealthEvent, + + /++ + + +/ + entityAirChangeEvent, + + /++ + + +/ + entityBreedEvent, + + /++ + + +/ + entityDismountEvent, + + /++ + + +/ + entityDyeEvent, + + /++ + + +/ + entityEnterLoveModeEvent, + + /++ + + +/ + entityExplodeEvent, + + /++ + + +/ + entityMountEvent, + + /++ + + +/ + entityPickupItemEvent, + + /++ + + +/ + entityPortalEvent, + + /++ + + +/ + entityResurrectEvent, + + /++ + + +/ + entityShootBowEvent, + + /++ + + +/ + entityTameEvent, + + /++ + + +/ + entityTargetEvent, + + /++ + + +/ + entityTeleportEvent, + + /++ + + +/ + entityToggleGlideEvent, + + /++ + + +/ + entityTransformEvent, + + /++ + + +/ + playerItemConsumeEvent, + + /++ + + +/ + playerItemDamageEvent, + + /++ + + +/ + playerDropItemEvent, + + /++ + + +/ + playerBedEnterEvent, + + /++ + + +/ + playerBedLeaveEvent, + + /++ + + +/ + playerBucketEmptyEvent, + + /++ + + +/ + playerBucketFillEvent, + + /++ + + +/ + blockDamageEvent, + + /++ + + +/ + blockIgniteEvent, + + /++ + + +/ + blockFromToEvent, + + /++ + + +/ + blockFormEvent, + + /++ + + +/ + blockFadeEvent, + + /++ + + +/ + blockDispenseEvent, + + /++ + + +/ + blockExplodeEvent, + + /++ + + +/ + blockPhysicsEvent, + + /++ + + +/ + blockPistonExtendEvent, + + /++ + + +/ + blockPistonRetractEvent, + + /++ + + +/ + notePlayEvent, + + /++ + + +/ + signChangeEvent, + + /++ + + +/ + spongeAbsorbEvent, + + /++ + + +/ + tntPrimeEvent, + + /++ + + +/ + weatherChangeEvent, + + /++ + + +/ + thunderChangeEvent, + + /++ + + +/ + worldLoadEvent, + + /++ + + +/ + worldUnloadEvent, + + /++ + + +/ + asyncStructureGenerateEvent, + + /++ + + +/ + asyncStructureSpawnEvent, + + /++ + + +/ + chunkPopulateEvent, + + /++ + + +/ + chunkUnloadEvent, + + /++ + + +/ + entitiesLoadEvent, + + /++ + + +/ + entitiesUnloadEvent, + + /++ + + +/ + genericGameEvent, + + /++ + + +/ + lootGenerateEvent, + + /++ + + +/ + portalCreateEvent, + + /++ + + +/ + structureGrowEvent, + + /++ + + +/ + timeSkipEvent, + + /++ + + +/ + worldInitEvent, + + /++ + + +/ + worldSaveEvent, + + /++ + + +/ + inventoryOpenEvent, + + /++ + + +/ + inventoryDragEvent, + + /++ + + +/ + craftItemEvent, + + /++ + + +/ + furnaceSmeltEvent, + + /++ + + +/ + brewEvent, + + /++ + + +/ + brewingStandFuelEvent, + + /++ + + +/ + furnaceBurnEvent, + + /++ + + +/ + furnaceExtractEvent, + + /++ + + +/ + furnaceStartSmeltEvent, + + /++ + + +/ + hopperInventorySearchEvent, + + /++ + + +/ + inventoryCreativeEvent, + + /++ + + +/ + inventoryInteractEvent, + + /++ + + +/ + inventoryMoveItemEvent, + + /++ + + +/ + inventoryPickupItemEvent, + + /++ + + +/ + prepareAnvilEvent, + + /++ + + +/ + prepareGrindstoneEvent, + + /++ + + +/ + prepareInventoryResultEvent, + + /++ + + +/ + prepareItemCraftEvent, + + /++ + + +/ + prepareSmithingEvent, + + /++ + + +/ + smithItemEvent, + + /++ + + +/ + tradeSelectEvent, + + /++ + + +/ + vehicleBlockCollisionEvent, + + /++ + + +/ + vehicleCollisionEvent, + + /++ + + +/ + vehicleCreateEvent, + + /++ + + +/ + vehicleDamageEvent, + + /++ + + +/ + vehicleDestroyEvent, + + /++ + + +/ + vehicleEnterEvent, + + /++ + + +/ + vehicleEntityCollisionEvent, + + /++ + + +/ + vehicleExitEvent, + + /++ + + +/ + vehicleMoveEvent, + + /++ + + +/ + vehicleUpdateEvent, + + /++ + + +/ + prepareItemEnchantEvent, + + /++ + + +/ + enchantItemEvent, + + /++ + + +/ + mapInitializeEvent, + + /++ + + +/ + hangingBreakEvent, + + /++ + + +/ + hangingBreakByEntityEvent, + + /++ + + +/ + hangingPlaceEvent, + + /++ + + +/ + bellResonateEvent, + + /++ + + +/ + bellRingEvent, + + /++ + + +/ + blockBrushEvent, + + /++ + + +/ + blockCookEvent, + + /++ + + +/ + blockDamageAbortEvent, + + /++ + + +/ + blockDispenseArmorEvent, + + /++ + + +/ + blockDispenseLootEvent, + + /++ + + +/ + blockDropItemEvent, + + /++ + + +/ + blockExpEvent, + + /++ + + +/ + blockFertilizeEvent, + + /++ + + +/ + blockMultiPlaceEvent, + + /++ + + +/ + blockReceiveGameEvent, + + /++ + + +/ + blockShearEntityEvent, + + /++ + + +/ + blockSpreadEvent, + + /++ + + +/ + brewingStartEvent, + + /++ + + +/ + campfireStartEvent, + + /++ + + +/ + cauldronLevelChangeEvent, + + /++ + + +/ + crafterCraftEvent, + + /++ + + +/ + entityBlockFormEvent, + + /++ + + +/ + fluidLevelChangeEvent, + + /++ + + +/ + inventoryBlockStartEvent, + + /++ + + +/ + leavesDecayEvent, + + /++ + + +/ + moistureChangeEvent, + + /++ + + +/ + sculkBloomEvent, + + /++ + + +/ + vaultDisplayItemEvent, + + /++ + + +/ + creatureSpawnEvent, + + /++ + + +/ + enderDragonChangePhaseEvent, + + /++ + + +/ + entityBreakDoorEvent, + + /++ + + +/ + entityChangeBlockEvent, + + /++ + + +/ + entityDamageByBlockEvent, + + /++ + + +/ + entityDamageByEntityEvent, + + /++ + + +/ + entityDropItemEvent, + + /++ + + +/ + entityEnterBlockEvent, + + /++ + + +/ + entityExhaustionEvent, + + /++ + + +/ + entityInteractEvent, + + /++ + + +/ + entityKnockbackEvent, + + /++ + + +/ + entityPlaceEvent, + + /++ + + +/ + entityPoseChangeEvent, + + /++ + + +/ + entityPotionEffectEvent, + + /++ + + +/ + entitySpellCastEvent, + + /++ + + +/ + entityTargetLivingEntityEvent, + + /++ + + +/ + entityToggleSwimEvent, + + /++ + + +/ + explosionPrimeEvent, + + /++ + + +/ + fireworkExplodeEvent, + + /++ + + +/ + foodLevelChangeEvent, + + /++ + + +/ + itemDespawnEvent, + + /++ + + +/ + itemMergeEvent, + + /++ + + +/ + itemSpawnEvent, + + /++ + + +/ + piglinBarterEvent, + + /++ + + +/ + projectileHitEvent, + + /++ + + +/ + projectileLaunchEvent, + + /++ + + +/ + sheepDyeWoolEvent, + + /++ + + +/ + sheepRegrowWoolEvent, + + /++ + + +/ + slimeSplitEvent, + + /++ + + +/ + striderTemperatureChangeEvent, + + /++ + + +/ + villagerAcquireTradeEvent, + + /++ + + +/ + villagerCareerChangeEvent, + + /++ + + +/ + villagerReplenishTradeEvent, + + /++ + + +/ + wardenAngerChangeEvent, + + /++ + + +/ + areaEffectCloudApplyEvent, + + /++ + + +/ + arrowBodyCountChangeEvent, + + /++ + + +/ + batToggleSleepEvent, + + /++ + + +/ + creeperPowerEvent, + + /++ + + +/ + entityCombustByBlockEvent, + + /++ + + +/ + entityCombustByEntityEvent, + + /++ + + +/ + entityKnockbackByEntityEvent, + + /++ + + +/ + entityPortalEnterEvent, + + /++ + + +/ + entityPortalExitEvent, + + /++ + + +/ + entityRemoveEvent, + + /++ + + +/ + entityTargetBlockEvent, + + /++ + + +/ + entityUnleashEvent, + + /++ + + +/ + expBottleEvent, + + /++ + + +/ + horseJumpEvent, + + /++ + + +/ + lingeringPotionSplashEvent, + + /++ + + +/ + pigZapEvent, + + /++ + + +/ + pigZombieAngerEvent, + + /++ + + +/ + potionSplashEvent, + + /++ + + +/ + spawnerSpawnEvent, + + /++ + + +/ + trialSpawnerSpawnEvent, + + /++ + + +/ + villagerReputationChangeEvent, + + /++ + + +/ + asyncPlayerChatEvent, + + /++ + + +/ + asyncPlayerPreLoginEvent, + + /++ + + +/ + playerAdvancementDoneEvent, + + /++ + + +/ + playerAnimationEvent, + + /++ + + +/ + playerArmorStandManipulateEvent, + + /++ + + +/ + playerBucketEntityEvent, + + /++ + + +/ + playerChangedWorldEvent, + + /++ + + +/ + playerChannelEvent, + + /++ + + +/ + playerCommandPreprocessEvent, + + /++ + + +/ + playerEditBookEvent, + + /++ + + +/ + playerElytraBoostEvent, + + /++ + + +/ + playerExpCooldownChangeEvent, + + /++ + + +/ + playerHarvestBlockEvent, + + /++ + + +/ + playerHideEntityEvent, + + /++ + + +/ + playerItemBreakEvent, + + /++ + + +/ + playerItemMendEvent, + + /++ + + +/ + playerKickEvent, + + /++ + + +/ + playerLeashEntityEvent, + + /++ + + +/ + playerLevelChangeEvent, + + /++ + + +/ + playerLocaleChangeEvent, + + /++ + + +/ + playerNameEntityEvent, + + /++ + + +/ + playerOpenSignEvent, + + /++ + + +/ + playerPortalEvent, + + /++ + + +/ + playerPreLoginEvent, + + /++ + + +/ + playerRiptideEvent, + + /++ + + +/ + playerShearEntityEvent, + + /++ + + +/ + playerShowEntityEvent, + + /++ + + +/ + playerSpawnChangeEvent, + + /++ + + +/ + playerStatisticIncrementEvent, + + /++ + + +/ + playerSwapHandsEvent, + + /++ + + +/ + playerTakeLecternBookEvent, + + /++ + + +/ + playerUnleashEntityEvent, + + /++ + + +/ + playerVelocityEvent, + + /++ + + +/ + playerInputEvent, + + /++ + + +/ + playerInteractAtEntityEvent, + + /++ + + +/ + playerLinksSendEvent, + + /++ + + +/ + playerPickupArrowEvent, + + /++ + + +/ + playerRecipeBookClickEvent, + + /++ + + +/ + playerRecipeBookSettingsChangeEvent, + + /++ + + +/ + playerRecipeDiscoverEvent, + + /++ + + +/ + playerRegisterChannelEvent, + + /++ + + +/ + playerResourcePackStatusEvent, + + /++ + + +/ + playerSpawnLocationEvent, + + /++ + + +/ + playerUnregisterChannelEvent, + + /++ + + +/ + raidFinishEvent, + + /++ + + +/ + raidSpawnWaveEvent, + + /++ + + +/ + raidStopEvent, + + /++ + + +/ + raidTriggerEvent, + + /++ + + +/ + lightningStrikeEvent, +} \ No newline at end of file diff --git a/src/wit/pumpkin/plugin/event/imports.d b/src/wit/pumpkin/plugin/event/imports.d new file mode 100644 index 0000000..e7e6e35 --- /dev/null +++ b/src/wit/pumpkin/plugin/event/imports.d @@ -0,0 +1,10791 @@ +/++ + ++/ +module wit.pumpkin.plugin.event.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.event.common; + +static import wit.pumpkin.plugin.common.imports; +static import wit.pumpkin.plugin.damage_types.imports; +static import wit.pumpkin.plugin.screens.imports; +static import wit.pumpkin.plugin.text.imports; +static import wit.pumpkin.plugin.enchantments.imports; +static import wit.pumpkin.plugin.item_stack.imports; +static import wit.pumpkin.plugin.java_dialogs.imports; +static import wit.pumpkin.plugin.uuid.imports; +static import wit.pumpkin.plugin.bedrock_packets.imports; +static import wit.pumpkin.plugin.java_packets.imports; +static import wit.pumpkin.plugin.world.imports; +static import wit.pumpkin.plugin.player.imports; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias ItemStack = wit.pumpkin.plugin.item_stack.imports.ItemStack; + +/++ + ++/ +alias Player = wit.pumpkin.plugin.player.imports.Player; + +/++ + ++/ +alias TextComponent = wit.pumpkin.plugin.text.imports.TextComponent; + +/++ + ++/ +alias World = wit.pumpkin.plugin.world.imports.World; + +/++ + ++/ +alias Dialog = wit.pumpkin.plugin.java_dialogs.imports.Dialog; + +/++ + ++/ +struct PlayerJoinEventData { + /++ + + +/ + Player player; + + /++ + + +/ + TextComponent joinMessage; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + joinMessage.witDrop; + } + + PlayerJoinEventData witClone() const @nogc nothrow { + PlayerJoinEventData clone = void; + clone.player = this.player.witClone; + clone.joinMessage = this.joinMessage.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerLeaveEventData { + /++ + + +/ + Player player; + + /++ + + +/ + TextComponent leaveMessage; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + leaveMessage.witDrop; + } + + PlayerLeaveEventData witClone() const @nogc nothrow { + PlayerLeaveEventData clone = void; + clone.player = this.player.witClone; + clone.leaveMessage = this.leaveMessage.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerLoginEventData { + /++ + + +/ + Player player; + + /++ + + +/ + TextComponent kickMessage; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + kickMessage.witDrop; + } + + PlayerLoginEventData witClone() const @nogc nothrow { + PlayerLoginEventData clone = void; + clone.player = this.player.witClone; + clone.kickMessage = this.kickMessage.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerChatEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString message; + + /++ + + +/ + WitList!(Player) recipients; + + /++ + + +/ + Option!(WitList!(ubyte)) signature; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + message.witFree; + recipients.witFree; + signature.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + recipients.witDrop; + } + + PlayerChatEventData witClone() const @nogc nothrow { + PlayerChatEventData clone = void; + clone.player = this.player.witClone; + clone.message = this.message.witClone; + clone.recipients = this.recipients.witClone; + clone.signature = this.signature.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerCommandSendEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString command; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + command.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerCommandSendEventData witClone() const @nogc nothrow { + PlayerCommandSendEventData clone = void; + clone.player = this.player.witClone; + clone.command = this.command.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerPermissionCheckEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString permission; + + /++ + + +/ + bool permissionResult; + + void witFree() @nogc nothrow { + permission.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerPermissionCheckEventData witClone() const @nogc nothrow { + PlayerPermissionCheckEventData clone = void; + clone.player = this.player.witClone; + clone.permission = this.permission.witClone; + clone.permissionResult = this.permissionResult.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerMoveEventData { + /++ + + +/ + Player player; + + /++ + + +/ + Position fromPosition; + + /++ + + +/ + Position toPosition; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerMoveEventData witClone() const @nogc nothrow { + PlayerMoveEventData clone = void; + clone.player = this.player.witClone; + clone.fromPosition = this.fromPosition.witClone; + clone.toPosition = this.toPosition.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerTeleportEventData { + /++ + + +/ + Player player; + + /++ + + +/ + Position fromPosition; + + /++ + + +/ + Position toPosition; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerTeleportEventData witClone() const @nogc nothrow { + PlayerTeleportEventData clone = void; + clone.player = this.player.witClone; + clone.fromPosition = this.fromPosition.witClone; + clone.toPosition = this.toPosition.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerChangeWorldEventData { + /++ + + +/ + Player player; + + /++ + + +/ + World previousWorld; + + /++ + + +/ + World newWorld; + + /++ + + +/ + Position position; + + /++ + + +/ + float yaw; + + /++ + + +/ + float pitch; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + previousWorld.witDrop; + newWorld.witDrop; + } + + PlayerChangeWorldEventData witClone() const @nogc nothrow { + PlayerChangeWorldEventData clone = void; + clone.player = this.player.witClone; + clone.previousWorld = this.previousWorld.witClone; + clone.newWorld = this.newWorld.witClone; + clone.position = this.position.witClone; + clone.yaw = this.yaw.witClone; + clone.pitch = this.pitch.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerRespawnEventData { + /++ + + +/ + Player player; + + /++ + + +/ + World previousWorld; + + /++ + + +/ + World respawnedWorld; + + /++ + + +/ + Position position; + + /++ + + +/ + float yaw; + + /++ + + +/ + float pitch; + + /++ + + +/ + bool alive; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + previousWorld.witDrop; + respawnedWorld.witDrop; + } + + PlayerRespawnEventData witClone() const @nogc nothrow { + PlayerRespawnEventData clone = void; + clone.player = this.player.witClone; + clone.previousWorld = this.previousWorld.witClone; + clone.respawnedWorld = this.respawnedWorld.witClone; + clone.position = this.position.witClone; + clone.yaw = this.yaw.witClone; + clone.pitch = this.pitch.witClone; + clone.alive = this.alive.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerExpChangeEventData { + /++ + + +/ + Player player; + + /++ + + +/ + int amount; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerExpChangeEventData witClone() const @nogc nothrow { + PlayerExpChangeEventData clone = void; + clone.player = this.player.witClone; + clone.amount = this.amount.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerItemHeldEventData { + /++ + + +/ + Player player; + + /++ + + +/ + ubyte previousSlot; + + /++ + + +/ + ubyte newSlot; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerItemHeldEventData witClone() const @nogc nothrow { + PlayerItemHeldEventData clone = void; + clone.player = this.player.witClone; + clone.previousSlot = this.previousSlot.witClone; + clone.newSlot = this.newSlot.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerChangedMainHandEventData { + /++ + + +/ + Player player; + + /++ + + +/ + Hand mainHand; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerChangedMainHandEventData witClone() const @nogc nothrow { + PlayerChangedMainHandEventData clone = void; + clone.player = this.player.witClone; + clone.mainHand = this.mainHand.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerGamemodeChangeEventData { + /++ + + +/ + Player player; + + /++ + + +/ + GameMode previousGamemode; + + /++ + + +/ + GameMode newGamemode; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerGamemodeChangeEventData witClone() const @nogc nothrow { + PlayerGamemodeChangeEventData clone = void; + clone.player = this.player.witClone; + clone.previousGamemode = this.previousGamemode.witClone; + clone.newGamemode = this.newGamemode.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerCustomPayloadEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString channel; + + /++ + + +/ + WitList!(ubyte) data; + + void witFree() @nogc nothrow { + channel.witFree; + data.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerCustomPayloadEventData witClone() const @nogc nothrow { + PlayerCustomPayloadEventData clone = void; + clone.player = this.player.witClone; + clone.channel = this.channel.witClone; + clone.data = this.data.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerFishEventData { + /++ + + +/ + Player player; + + /++ + + +/ + Option!(Uuid) caughtUuid; + + /++ + + +/ + WitString caughtType; + + /++ + + +/ + Uuid hookUuid; + + /++ + + +/ + PlayerFishState state; + + /++ + + +/ + Hand hand; + + /++ + + +/ + int expToDrop; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + caughtType.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerFishEventData witClone() const @nogc nothrow { + PlayerFishEventData clone = void; + clone.player = this.player.witClone; + clone.caughtUuid = this.caughtUuid.witClone; + clone.caughtType = this.caughtType.witClone; + clone.hookUuid = this.hookUuid.witClone; + clone.state = this.state.witClone; + clone.hand = this.hand.witClone; + clone.expToDrop = this.expToDrop.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerEggThrowEventData { + /++ + + +/ + Player player; + + /++ + + +/ + Uuid eggUuid; + + /++ + + +/ + bool hatching; + + /++ + + +/ + ubyte numHatches; + + /++ + + +/ + WitString hatchingType; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + hatchingType.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerEggThrowEventData witClone() const @nogc nothrow { + PlayerEggThrowEventData clone = void; + clone.player = this.player.witClone; + clone.eggUuid = this.eggUuid.witClone; + clone.hatching = this.hatching.witClone; + clone.numHatches = this.numHatches.witClone; + clone.hatchingType = this.hatchingType.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerInteractEventData { + /++ + + +/ + Player player; + + /++ + + +/ + InteractAction action; + + /++ + + +/ + Option!(BlockPos) clickedPos; + + /++ + + +/ + WitString block; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + block.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerInteractEventData witClone() const @nogc nothrow { + PlayerInteractEventData clone = void; + clone.player = this.player.witClone; + clone.action = this.action.witClone; + clone.clickedPos = this.clickedPos.witClone; + clone.block = this.block.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerToggleSneakEventData { + /++ + + +/ + Player player; + + /++ + + +/ + bool isSneaking; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerToggleSneakEventData witClone() const @nogc nothrow { + PlayerToggleSneakEventData clone = void; + clone.player = this.player.witClone; + clone.isSneaking = this.isSneaking.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerToggleFlightEventData { + /++ + + +/ + Player player; + + /++ + + +/ + bool isFlying; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerToggleFlightEventData witClone() const @nogc nothrow { + PlayerToggleFlightEventData clone = void; + clone.player = this.player.witClone; + clone.isFlying = this.isFlying.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerToggleSprintEventData { + /++ + + +/ + Player player; + + /++ + + +/ + bool isSprinting; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerToggleSprintEventData witClone() const @nogc nothrow { + PlayerToggleSprintEventData clone = void; + clone.player = this.player.witClone; + clone.isSprinting = this.isSprinting.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerInteractUnknownEntityEventData { + /++ + + +/ + Player player; + + /++ + + +/ + int entityId; + + /++ + + +/ + EntityInteractionAction action; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerInteractUnknownEntityEventData witClone() const @nogc nothrow { + PlayerInteractUnknownEntityEventData clone = void; + clone.player = this.player.witClone; + clone.entityId = this.entityId.witClone; + clone.action = this.action.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct InventoryClickEventData { + /++ + + +/ + Player player; + + /++ + + +/ + Option!(Screen) windowType; + + /++ + + +/ + ClickType clickType; + + /++ + + +/ + short slot; + + /++ + + +/ + short rawSlot; + + /++ + + +/ + Option!(ItemStack) clickedItem; + + /++ + + +/ + Option!(ItemStack) cursor; + + /++ + + +/ + int hotbarButton; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + clickedItem.witDrop; + cursor.witDrop; + } + + InventoryClickEventData witClone() const @nogc nothrow { + InventoryClickEventData clone = void; + clone.player = this.player.witClone; + clone.windowType = this.windowType.witClone; + clone.clickType = this.clickType.witClone; + clone.slot = this.slot.witClone; + clone.rawSlot = this.rawSlot.witClone; + clone.clickedItem = this.clickedItem.witClone; + clone.cursor = this.cursor.witClone; + clone.hotbarButton = this.hotbarButton.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct InventoryCloseEventData { + /++ + + +/ + Player player; + + /++ + + +/ + Option!(Screen) windowType; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + InventoryCloseEventData witClone() const @nogc nothrow { + InventoryCloseEventData clone = void; + clone.player = this.player.witClone; + clone.windowType = this.windowType.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockRedstoneEventData { + /++ + + +/ + World targetWorld; + + /++ + + +/ + ushort stateId; + + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + int oldCurrent; + + /++ + + +/ + int newCurrent; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + BlockRedstoneEventData witClone() const @nogc nothrow { + BlockRedstoneEventData clone = void; + clone.targetWorld = this.targetWorld.witClone; + clone.stateId = this.stateId.witClone; + clone.blockPos = this.blockPos.witClone; + clone.oldCurrent = this.oldCurrent.witClone; + clone.newCurrent = this.newCurrent.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockBreakEventData { + /++ + + +/ + Option!(Player) player; + + /++ + + +/ + WitString block; + + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + uint exp; + + /++ + + +/ + bool shouldDrop; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + block.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + BlockBreakEventData witClone() const @nogc nothrow { + BlockBreakEventData clone = void; + clone.player = this.player.witClone; + clone.block = this.block.witClone; + clone.blockPos = this.blockPos.witClone; + clone.exp = this.exp.witClone; + clone.shouldDrop = this.shouldDrop.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockCanBuildEventData { + /++ + + +/ + WitString blockToBuild; + + /++ + + +/ + bool buildable; + + /++ + + +/ + Player player; + + /++ + + +/ + WitString block; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + blockToBuild.witFree; + block.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + BlockCanBuildEventData witClone() const @nogc nothrow { + BlockCanBuildEventData clone = void; + clone.blockToBuild = this.blockToBuild.witClone; + clone.buildable = this.buildable.witClone; + clone.player = this.player.witClone; + clone.block = this.block.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockGrowEventData { + /++ + + +/ + World targetWorld; + + /++ + + +/ + WitString oldBlock; + + /++ + + +/ + ushort oldStateId; + + /++ + + +/ + WitString newBlock; + + /++ + + +/ + ushort newStateId; + + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + oldBlock.witFree; + newBlock.witFree; + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + BlockGrowEventData witClone() const @nogc nothrow { + BlockGrowEventData clone = void; + clone.targetWorld = this.targetWorld.witClone; + clone.oldBlock = this.oldBlock.witClone; + clone.oldStateId = this.oldStateId.witClone; + clone.newBlock = this.newBlock.witClone; + clone.newStateId = this.newStateId.witClone; + clone.blockPos = this.blockPos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockPlaceEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString blockPlaced; + + /++ + + +/ + WitString blockPlacedAgainst; + + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + bool canBuild; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + blockPlaced.witFree; + blockPlacedAgainst.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + BlockPlaceEventData witClone() const @nogc nothrow { + BlockPlaceEventData clone = void; + clone.player = this.player.witClone; + clone.blockPlaced = this.blockPlaced.witClone; + clone.blockPlacedAgainst = this.blockPlacedAgainst.witClone; + clone.blockPos = this.blockPos.witClone; + clone.canBuild = this.canBuild.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BedrockFormResponseEventData { + /++ + + +/ + Player player; + + /++ + + +/ + uint formId; + + /++ + + +/ + Option!(WitString) responseData; + + void witFree() @nogc nothrow { + responseData.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + BedrockFormResponseEventData witClone() const @nogc nothrow { + BedrockFormResponseEventData clone = void; + clone.player = this.player.witClone; + clone.formId = this.formId.witClone; + clone.responseData = this.responseData.witClone; + return clone; + } +} + +/++ + ++/ +struct DialogClickActionEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString id; + + /++ + + +/ + Option!(WitList!(ubyte)) payload; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + id.witFree; + payload.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + DialogClickActionEventData witClone() const @nogc nothrow { + DialogClickActionEventData clone = void; + clone.player = this.player.witClone; + clone.id = this.id.witClone; + clone.payload = this.payload.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct DialogShowEventData { + /++ + + +/ + Player player; + + /++ + + +/ + Dialog dialog; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + dialog.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + dialog.witDrop; + } + + DialogShowEventData witClone() const @nogc nothrow { + DialogShowEventData clone = void; + clone.player = this.player.witClone; + clone.dialog = this.dialog.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct DialogClearEventData { + /++ + + +/ + Player player; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + DialogClearEventData witClone() const @nogc nothrow { + DialogClearEventData clone = void; + clone.player = this.player.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct ServerListPingEventData { + /++ + + +/ + WitString hostname; + + /++ + + +/ + ServerListPingAddress address; + + /++ + + +/ + TextComponent motd; + + /++ + + +/ + uint maxPlayers; + + /++ + + +/ + uint numPlayers; + + /++ + + +/ + Option!(WitString) favicon; + + void witFree() @nogc nothrow { + hostname.witFree; + address.witFree; + favicon.witFree; + } + + void witDrop() @nogc nothrow { + motd.witDrop; + } + + ServerListPingEventData witClone() const @nogc nothrow { + ServerListPingEventData clone = void; + clone.hostname = this.hostname.witClone; + clone.address = this.address.witClone; + clone.motd = this.motd.witClone; + clone.maxPlayers = this.maxPlayers.witClone; + clone.numPlayers = this.numPlayers.witClone; + clone.favicon = this.favicon.witClone; + return clone; + } +} + +/++ + ++/ +struct SpawnChangeEventData { + /++ + + +/ + World targetWorld; + + /++ + + +/ + BlockPos previousPosition; + + /++ + + +/ + float previousYaw; + + /++ + + +/ + float previousPitch; + + /++ + + +/ + BlockPos newPosition; + + /++ + + +/ + float newYaw; + + /++ + + +/ + float newPitch; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + SpawnChangeEventData witClone() const @nogc nothrow { + SpawnChangeEventData clone = void; + clone.targetWorld = this.targetWorld.witClone; + clone.previousPosition = this.previousPosition.witClone; + clone.previousYaw = this.previousYaw.witClone; + clone.previousPitch = this.previousPitch.witClone; + clone.newPosition = this.newPosition.witClone; + clone.newYaw = this.newYaw.witClone; + clone.newPitch = this.newPitch.witClone; + return clone; + } +} + +/++ + ++/ +struct ServerBroadcastEventData { + /++ + + +/ + TextComponent message; + + /++ + + +/ + TextComponent sender; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + message.witDrop; + sender.witDrop; + } + + ServerBroadcastEventData witClone() const @nogc nothrow { + ServerBroadcastEventData clone = void; + clone.message = this.message.witClone; + clone.sender = this.sender.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PacketReceivedEventData { + /++ + + +/ + Player player; + + /++ + + +/ + ServerboundPacket packet; + + /++ + + +/ + int packetId; + + /++ + + +/ + WitList!(ubyte) rawPayload; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + packet.witFree; + rawPayload.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PacketReceivedEventData witClone() const @nogc nothrow { + PacketReceivedEventData clone = void; + clone.player = this.player.witClone; + clone.packet = this.packet.witClone; + clone.packetId = this.packetId.witClone; + clone.rawPayload = this.rawPayload.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PacketSentEventData { + /++ + + +/ + Player player; + + /++ + + +/ + ClientboundPacket packet; + + /++ + + +/ + int packetId; + + /++ + + +/ + WitList!(ubyte) rawPayload; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + packet.witFree; + rawPayload.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PacketSentEventData witClone() const @nogc nothrow { + PacketSentEventData clone = void; + clone.player = this.player.witClone; + clone.packet = this.packet.witClone; + clone.packetId = this.packetId.witClone; + clone.rawPayload = this.rawPayload.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerInteractEntityEventData { + /++ + + +/ + Player player; + + /++ + + +/ + int entityId; + + /++ + + +/ + EntityInteractionAction action; + + /++ + + +/ + bool sneaking; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerInteractEntityEventData witClone() const @nogc nothrow { + PlayerInteractEntityEventData clone = void; + clone.player = this.player.witClone; + clone.entityId = this.entityId.witClone; + clone.action = this.action.witClone; + clone.sneaking = this.sneaking.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct ChunkLoadEventData { + /++ + + +/ + World targetWorld; + + /++ + + +/ + int chunkX; + + /++ + + +/ + int chunkZ; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + ChunkLoadEventData witClone() const @nogc nothrow { + ChunkLoadEventData clone = void; + clone.targetWorld = this.targetWorld.witClone; + clone.chunkX = this.chunkX.witClone; + clone.chunkZ = this.chunkZ.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct ChunkSaveEventData { + /++ + + +/ + World targetWorld; + + /++ + + +/ + int chunkX; + + /++ + + +/ + int chunkZ; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + ChunkSaveEventData witClone() const @nogc nothrow { + ChunkSaveEventData clone = void; + clone.targetWorld = this.targetWorld.witClone; + clone.chunkX = this.chunkX.witClone; + clone.chunkZ = this.chunkZ.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct ChunkSendEventData { + /++ + + +/ + World targetWorld; + + /++ + + +/ + int chunkX; + + /++ + + +/ + int chunkZ; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + ChunkSendEventData witClone() const @nogc nothrow { + ChunkSendEventData clone = void; + clone.targetWorld = this.targetWorld.witClone; + clone.chunkX = this.chunkX.witClone; + clone.chunkZ = this.chunkZ.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerDeathEventData { + /++ + + +/ + Player player; + + /++ + + +/ + TextComponent deathMessage; + + /++ + + +/ + int droppedExp; + + /++ + + +/ + bool keepInventory; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + deathMessage.witDrop; + } + + PlayerDeathEventData witClone() const @nogc nothrow { + PlayerDeathEventData clone = void; + clone.player = this.player.witClone; + clone.deathMessage = this.deathMessage.witClone; + clone.droppedExp = this.droppedExp.witClone; + clone.keepInventory = this.keepInventory.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntitySpawnEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + WitString entityType; + + /++ + + +/ + Position position; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + entityType.witFree; + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + EntitySpawnEventData witClone() const @nogc nothrow { + EntitySpawnEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.entityType = this.entityType.witClone; + clone.position = this.position.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityDyeEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + WitString color; + + /++ + + +/ + Option!(Player) player; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + color.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + EntityDyeEventData witClone() const @nogc nothrow { + EntityDyeEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.color = this.color.witClone; + clone.player = this.player.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityTameEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + Player owner; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + owner.witDrop; + } + + EntityTameEventData witClone() const @nogc nothrow { + EntityTameEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.owner = this.owner.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct CreatureSpawnEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + WitString entityType; + + /++ + + +/ + Position position; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + WitString spawnReason; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + entityType.witFree; + spawnReason.witFree; + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + CreatureSpawnEventData witClone() const @nogc nothrow { + CreatureSpawnEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.entityType = this.entityType.witClone; + clone.position = this.position.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.spawnReason = this.spawnReason.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PiglinBarterEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + ItemStack inputItem; + + /++ + + +/ + WitList!(ItemStack) outcome; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + outcome.witFree; + } + + void witDrop() @nogc nothrow { + inputItem.witDrop; + outcome.witDrop; + } + + PiglinBarterEventData witClone() const @nogc nothrow { + PiglinBarterEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.inputItem = this.inputItem.witClone; + clone.outcome = this.outcome.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerItemConsumeEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString itemName; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + itemName.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerItemConsumeEventData witClone() const @nogc nothrow { + PlayerItemConsumeEventData clone = void; + clone.player = this.player.witClone; + clone.itemName = this.itemName.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerItemDamageEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString itemName; + + /++ + + +/ + int damage; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + itemName.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerItemDamageEventData witClone() const @nogc nothrow { + PlayerItemDamageEventData clone = void; + clone.player = this.player.witClone; + clone.itemName = this.itemName.witClone; + clone.damage = this.damage.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerDropItemEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString itemName; + + /++ + + +/ + ubyte count; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + itemName.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerDropItemEventData witClone() const @nogc nothrow { + PlayerDropItemEventData clone = void; + clone.player = this.player.witClone; + clone.itemName = this.itemName.witClone; + clone.count = this.count.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerBedEnterEventData { + /++ + + +/ + Player player; + + /++ + + +/ + BlockPos bedPos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerBedEnterEventData witClone() const @nogc nothrow { + PlayerBedEnterEventData clone = void; + clone.player = this.player.witClone; + clone.bedPos = this.bedPos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerBedLeaveEventData { + /++ + + +/ + Player player; + + /++ + + +/ + BlockPos bedPos; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerBedLeaveEventData witClone() const @nogc nothrow { + PlayerBedLeaveEventData clone = void; + clone.player = this.player.witClone; + clone.bedPos = this.bedPos.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerBucketEmptyEventData { + /++ + + +/ + Player player; + + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + WitString bucket; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + bucket.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerBucketEmptyEventData witClone() const @nogc nothrow { + PlayerBucketEmptyEventData clone = void; + clone.player = this.player.witClone; + clone.blockPos = this.blockPos.witClone; + clone.bucket = this.bucket.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerBucketFillEventData { + /++ + + +/ + Player player; + + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + WitString bucket; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + bucket.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerBucketFillEventData witClone() const @nogc nothrow { + PlayerBucketFillEventData clone = void; + clone.player = this.player.witClone; + clone.blockPos = this.blockPos.witClone; + clone.bucket = this.bucket.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct AsyncPlayerChatEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString message; + + /++ + + +/ + TextComponent format; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + message.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + format.witDrop; + } + + AsyncPlayerChatEventData witClone() const @nogc nothrow { + AsyncPlayerChatEventData clone = void; + clone.player = this.player.witClone; + clone.message = this.message.witClone; + clone.format = this.format.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct AsyncPlayerPreLoginEventData { + /++ + + +/ + WitString playerName; + + /++ + + +/ + WitString playerUuid; + + /++ + + +/ + WitString ipAddress; + + /++ + + +/ + TextComponent kickMessage; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + playerName.witFree; + playerUuid.witFree; + ipAddress.witFree; + } + + void witDrop() @nogc nothrow { + kickMessage.witDrop; + } + + AsyncPlayerPreLoginEventData witClone() const @nogc nothrow { + AsyncPlayerPreLoginEventData clone = void; + clone.playerName = this.playerName.witClone; + clone.playerUuid = this.playerUuid.witClone; + clone.ipAddress = this.ipAddress.witClone; + clone.kickMessage = this.kickMessage.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerAdvancementDoneEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString advancementId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + advancementId.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerAdvancementDoneEventData witClone() const @nogc nothrow { + PlayerAdvancementDoneEventData clone = void; + clone.player = this.player.witClone; + clone.advancementId = this.advancementId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerAnimationEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString animationType; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + animationType.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerAnimationEventData witClone() const @nogc nothrow { + PlayerAnimationEventData clone = void; + clone.player = this.player.witClone; + clone.animationType = this.animationType.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerArmorStandManipulateEventData { + /++ + + +/ + Player player; + + /++ + + +/ + int armorStandId; + + /++ + + +/ + ubyte slot; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerArmorStandManipulateEventData witClone() const @nogc nothrow { + PlayerArmorStandManipulateEventData clone = void; + clone.player = this.player.witClone; + clone.armorStandId = this.armorStandId.witClone; + clone.slot = this.slot.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerBucketEntityEventData { + /++ + + +/ + Player player; + + /++ + + +/ + int entityId; + + /++ + + +/ + WitString bucketItem; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + bucketItem.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerBucketEntityEventData witClone() const @nogc nothrow { + PlayerBucketEntityEventData clone = void; + clone.player = this.player.witClone; + clone.entityId = this.entityId.witClone; + clone.bucketItem = this.bucketItem.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerChangedWorldEventData { + /++ + + +/ + Player player; + + /++ + + +/ + World fromWorld; + + /++ + + +/ + World toWorld; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + fromWorld.witDrop; + toWorld.witDrop; + } + + PlayerChangedWorldEventData witClone() const @nogc nothrow { + PlayerChangedWorldEventData clone = void; + clone.player = this.player.witClone; + clone.fromWorld = this.fromWorld.witClone; + clone.toWorld = this.toWorld.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerChannelEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString channel; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + channel.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerChannelEventData witClone() const @nogc nothrow { + PlayerChannelEventData clone = void; + clone.player = this.player.witClone; + clone.channel = this.channel.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerCommandPreprocessEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString command; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + command.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerCommandPreprocessEventData witClone() const @nogc nothrow { + PlayerCommandPreprocessEventData clone = void; + clone.player = this.player.witClone; + clone.command = this.command.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerEditBookEventData { + /++ + + +/ + Player player; + + /++ + + +/ + uint slot; + + /++ + + +/ + WitList!(WitString) pages; + + /++ + + +/ + Option!(WitString) title; + + /++ + + +/ + bool signing; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + pages.witFree; + title.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerEditBookEventData witClone() const @nogc nothrow { + PlayerEditBookEventData clone = void; + clone.player = this.player.witClone; + clone.slot = this.slot.witClone; + clone.pages = this.pages.witClone; + clone.title = this.title.witClone; + clone.signing = this.signing.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerElytraBoostEventData { + /++ + + +/ + Player player; + + /++ + + +/ + int fireworkId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerElytraBoostEventData witClone() const @nogc nothrow { + PlayerElytraBoostEventData clone = void; + clone.player = this.player.witClone; + clone.fireworkId = this.fireworkId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerExpCooldownChangeEventData { + /++ + + +/ + Player player; + + /++ + + +/ + int newCooldown; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerExpCooldownChangeEventData witClone() const @nogc nothrow { + PlayerExpCooldownChangeEventData clone = void; + clone.player = this.player.witClone; + clone.newCooldown = this.newCooldown.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerHarvestBlockEventData { + /++ + + +/ + Player player; + + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + WitList!(ItemStack) harvestedItems; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + harvestedItems.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + harvestedItems.witDrop; + } + + PlayerHarvestBlockEventData witClone() const @nogc nothrow { + PlayerHarvestBlockEventData clone = void; + clone.player = this.player.witClone; + clone.blockPos = this.blockPos.witClone; + clone.harvestedItems = this.harvestedItems.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerHideEntityEventData { + /++ + + +/ + Player player; + + /++ + + +/ + int entityId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerHideEntityEventData witClone() const @nogc nothrow { + PlayerHideEntityEventData clone = void; + clone.player = this.player.witClone; + clone.entityId = this.entityId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerItemBreakEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString itemName; + + void witFree() @nogc nothrow { + itemName.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerItemBreakEventData witClone() const @nogc nothrow { + PlayerItemBreakEventData clone = void; + clone.player = this.player.witClone; + clone.itemName = this.itemName.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerItemMendEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString itemName; + + /++ + + +/ + int repairAmount; + + /++ + + +/ + int expConsumed; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + itemName.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerItemMendEventData witClone() const @nogc nothrow { + PlayerItemMendEventData clone = void; + clone.player = this.player.witClone; + clone.itemName = this.itemName.witClone; + clone.repairAmount = this.repairAmount.witClone; + clone.expConsumed = this.expConsumed.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerKickEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString reason; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + reason.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerKickEventData witClone() const @nogc nothrow { + PlayerKickEventData clone = void; + clone.player = this.player.witClone; + clone.reason = this.reason.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerLeashEntityEventData { + /++ + + +/ + Player player; + + /++ + + +/ + int entityId; + + /++ + + +/ + int holderId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerLeashEntityEventData witClone() const @nogc nothrow { + PlayerLeashEntityEventData clone = void; + clone.player = this.player.witClone; + clone.entityId = this.entityId.witClone; + clone.holderId = this.holderId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerLevelChangeEventData { + /++ + + +/ + Player player; + + /++ + + +/ + int oldLevel; + + /++ + + +/ + int newLevel; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerLevelChangeEventData witClone() const @nogc nothrow { + PlayerLevelChangeEventData clone = void; + clone.player = this.player.witClone; + clone.oldLevel = this.oldLevel.witClone; + clone.newLevel = this.newLevel.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerLocaleChangeEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString newLocale; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + newLocale.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerLocaleChangeEventData witClone() const @nogc nothrow { + PlayerLocaleChangeEventData clone = void; + clone.player = this.player.witClone; + clone.newLocale = this.newLocale.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerNameEntityEventData { + /++ + + +/ + Player player; + + /++ + + +/ + int entityId; + + /++ + + +/ + TextComponent name; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + name.witDrop; + } + + PlayerNameEntityEventData witClone() const @nogc nothrow { + PlayerNameEntityEventData clone = void; + clone.player = this.player.witClone; + clone.entityId = this.entityId.witClone; + clone.name = this.name.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerOpenSignEventData { + /++ + + +/ + Player player; + + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + bool isFront; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerOpenSignEventData witClone() const @nogc nothrow { + PlayerOpenSignEventData clone = void; + clone.player = this.player.witClone; + clone.blockPos = this.blockPos.witClone; + clone.isFront = this.isFront.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerPortalEventData { + /++ + + +/ + Player player; + + /++ + + +/ + BlockPos fromPos; + + /++ + + +/ + Option!(BlockPos) toPos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerPortalEventData witClone() const @nogc nothrow { + PlayerPortalEventData clone = void; + clone.player = this.player.witClone; + clone.fromPos = this.fromPos.witClone; + clone.toPos = this.toPos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerPreLoginEventData { + /++ + + +/ + WitString playerName; + + /++ + + +/ + WitString playerUuid; + + /++ + + +/ + WitString ipAddress; + + /++ + + +/ + TextComponent kickMessage; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + playerName.witFree; + playerUuid.witFree; + ipAddress.witFree; + } + + void witDrop() @nogc nothrow { + kickMessage.witDrop; + } + + PlayerPreLoginEventData witClone() const @nogc nothrow { + PlayerPreLoginEventData clone = void; + clone.playerName = this.playerName.witClone; + clone.playerUuid = this.playerUuid.witClone; + clone.ipAddress = this.ipAddress.witClone; + clone.kickMessage = this.kickMessage.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerRiptideEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString itemName; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + itemName.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerRiptideEventData witClone() const @nogc nothrow { + PlayerRiptideEventData clone = void; + clone.player = this.player.witClone; + clone.itemName = this.itemName.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerShearEntityEventData { + /++ + + +/ + Player player; + + /++ + + +/ + int entityId; + + /++ + + +/ + ubyte hand; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerShearEntityEventData witClone() const @nogc nothrow { + PlayerShearEntityEventData clone = void; + clone.player = this.player.witClone; + clone.entityId = this.entityId.witClone; + clone.hand = this.hand.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerShowEntityEventData { + /++ + + +/ + Player player; + + /++ + + +/ + int entityId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerShowEntityEventData witClone() const @nogc nothrow { + PlayerShowEntityEventData clone = void; + clone.player = this.player.witClone; + clone.entityId = this.entityId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerSpawnChangeEventData { + /++ + + +/ + Player player; + + /++ + + +/ + Option!(BlockPos) newSpawn; + + /++ + + +/ + bool forced; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerSpawnChangeEventData witClone() const @nogc nothrow { + PlayerSpawnChangeEventData clone = void; + clone.player = this.player.witClone; + clone.newSpawn = this.newSpawn.witClone; + clone.forced = this.forced.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerStatisticIncrementEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString statisticId; + + /++ + + +/ + int amount; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + statisticId.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerStatisticIncrementEventData witClone() const @nogc nothrow { + PlayerStatisticIncrementEventData clone = void; + clone.player = this.player.witClone; + clone.statisticId = this.statisticId.witClone; + clone.amount = this.amount.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerSwapHandsEventData { + /++ + + +/ + Player player; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerSwapHandsEventData witClone() const @nogc nothrow { + PlayerSwapHandsEventData clone = void; + clone.player = this.player.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerTakeLecternBookEventData { + /++ + + +/ + Player player; + + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + ItemStack book; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + book.witDrop; + } + + PlayerTakeLecternBookEventData witClone() const @nogc nothrow { + PlayerTakeLecternBookEventData clone = void; + clone.player = this.player.witClone; + clone.blockPos = this.blockPos.witClone; + clone.book = this.book.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerUnleashEntityEventData { + /++ + + +/ + Player player; + + /++ + + +/ + int entityId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerUnleashEntityEventData witClone() const @nogc nothrow { + PlayerUnleashEntityEventData clone = void; + clone.player = this.player.witClone; + clone.entityId = this.entityId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerVelocityEventData { + /++ + + +/ + Player player; + + /++ + + +/ + Position velocity; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerVelocityEventData witClone() const @nogc nothrow { + PlayerVelocityEventData clone = void; + clone.player = this.player.witClone; + clone.velocity = this.velocity.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerInputEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString input; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + input.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerInputEventData witClone() const @nogc nothrow { + PlayerInputEventData clone = void; + clone.player = this.player.witClone; + clone.input = this.input.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerInteractAtEntityEventData { + /++ + + +/ + Player player; + + /++ + + +/ + int entityId; + + /++ + + +/ + double clickedX; + + /++ + + +/ + double clickedY; + + /++ + + +/ + double clickedZ; + + /++ + + +/ + ubyte hand; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerInteractAtEntityEventData witClone() const @nogc nothrow { + PlayerInteractAtEntityEventData clone = void; + clone.player = this.player.witClone; + clone.entityId = this.entityId.witClone; + clone.clickedX = this.clickedX.witClone; + clone.clickedY = this.clickedY.witClone; + clone.clickedZ = this.clickedZ.witClone; + clone.hand = this.hand.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerLinksSendEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitList!(WitString) links; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + links.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerLinksSendEventData witClone() const @nogc nothrow { + PlayerLinksSendEventData clone = void; + clone.player = this.player.witClone; + clone.links = this.links.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerPickupArrowEventData { + /++ + + +/ + Player player; + + /++ + + +/ + int arrowId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerPickupArrowEventData witClone() const @nogc nothrow { + PlayerPickupArrowEventData clone = void; + clone.player = this.player.witClone; + clone.arrowId = this.arrowId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerRecipeBookClickEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString recipeId; + + /++ + + +/ + bool makeAll; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + recipeId.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerRecipeBookClickEventData witClone() const @nogc nothrow { + PlayerRecipeBookClickEventData clone = void; + clone.player = this.player.witClone; + clone.recipeId = this.recipeId.witClone; + clone.makeAll = this.makeAll.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerRecipeBookSettingsChangeEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString bookType; + + /++ + + +/ + bool isOpen; + + /++ + + +/ + bool isFiltering; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + bookType.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerRecipeBookSettingsChangeEventData witClone() const @nogc nothrow { + PlayerRecipeBookSettingsChangeEventData clone = void; + clone.player = this.player.witClone; + clone.bookType = this.bookType.witClone; + clone.isOpen = this.isOpen.witClone; + clone.isFiltering = this.isFiltering.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerRecipeDiscoverEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString recipeId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + recipeId.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerRecipeDiscoverEventData witClone() const @nogc nothrow { + PlayerRecipeDiscoverEventData clone = void; + clone.player = this.player.witClone; + clone.recipeId = this.recipeId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerRegisterChannelEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString channel; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + channel.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerRegisterChannelEventData witClone() const @nogc nothrow { + PlayerRegisterChannelEventData clone = void; + clone.player = this.player.witClone; + clone.channel = this.channel.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerResourcePackStatusEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString packId; + + /++ + + +/ + WitString status; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + packId.witFree; + status.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerResourcePackStatusEventData witClone() const @nogc nothrow { + PlayerResourcePackStatusEventData clone = void; + clone.player = this.player.witClone; + clone.packId = this.packId.witClone; + clone.status = this.status.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerSpawnLocationEventData { + /++ + + +/ + Player player; + + /++ + + +/ + Position spawnPos; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerSpawnLocationEventData witClone() const @nogc nothrow { + PlayerSpawnLocationEventData clone = void; + clone.player = this.player.witClone; + clone.spawnPos = this.spawnPos.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerUnregisterChannelEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString channel; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + channel.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PlayerUnregisterChannelEventData witClone() const @nogc nothrow { + PlayerUnregisterChannelEventData clone = void; + clone.player = this.player.witClone; + clone.channel = this.channel.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockDamageEventData { + /++ + + +/ + Player player; + + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + bool instaBreak; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + BlockDamageEventData witClone() const @nogc nothrow { + BlockDamageEventData clone = void; + clone.player = this.player.witClone; + clone.blockPos = this.blockPos.witClone; + clone.instaBreak = this.instaBreak.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct SignChangeEventData { + /++ + + +/ + Player player; + + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + WitList!(WitString) lines; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + lines.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + SignChangeEventData witClone() const @nogc nothrow { + SignChangeEventData clone = void; + clone.player = this.player.witClone; + clone.blockPos = this.blockPos.witClone; + clone.lines = this.lines.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct HangingPlaceEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + Option!(Player) player; + + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + WitString blockFace; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + blockFace.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + HangingPlaceEventData witClone() const @nogc nothrow { + HangingPlaceEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.player = this.player.witClone; + clone.blockPos = this.blockPos.witClone; + clone.blockFace = this.blockFace.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BellResonateEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + BellResonateEventData witClone() const @nogc nothrow { + BellResonateEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BellRingEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + Option!(int) entityId; + + /++ + + +/ + Option!(WitString) direction; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + direction.witFree; + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + BellRingEventData witClone() const @nogc nothrow { + BellRingEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.entityId = this.entityId.witClone; + clone.direction = this.direction.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockBrushEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + Player player; + + /++ + + +/ + ItemStack item; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + player.witDrop; + item.witDrop; + } + + BlockBrushEventData witClone() const @nogc nothrow { + BlockBrushEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.player = this.player.witClone; + clone.item = this.item.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockCookEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + ItemStack source; + + /++ + + +/ + ItemStack result; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + source.witDrop; + result.witDrop; + } + + BlockCookEventData witClone() const @nogc nothrow { + BlockCookEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.source = this.source.witClone; + clone.result = this.result.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockDamageAbortEventData { + /++ + + +/ + Player player; + + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + ItemStack itemInHand; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + targetWorld.witDrop; + itemInHand.witDrop; + } + + BlockDamageAbortEventData witClone() const @nogc nothrow { + BlockDamageAbortEventData clone = void; + clone.player = this.player.witClone; + clone.blockPos = this.blockPos.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.itemInHand = this.itemInHand.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockDispenseArmorEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + int targetEntityId; + + /++ + + +/ + ItemStack item; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + item.witDrop; + } + + BlockDispenseArmorEventData witClone() const @nogc nothrow { + BlockDispenseArmorEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.targetEntityId = this.targetEntityId.witClone; + clone.item = this.item.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockDispenseLootEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + WitList!(ItemStack) items; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + items.witFree; + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + items.witDrop; + } + + BlockDispenseLootEventData witClone() const @nogc nothrow { + BlockDispenseLootEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.items = this.items.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockDropItemEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + Option!(Player) player; + + /++ + + +/ + WitList!(ItemStack) items; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + items.witFree; + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + player.witDrop; + items.witDrop; + } + + BlockDropItemEventData witClone() const @nogc nothrow { + BlockDropItemEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.player = this.player.witClone; + clone.items = this.items.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockExpEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + int exp; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + BlockExpEventData witClone() const @nogc nothrow { + BlockExpEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.exp = this.exp.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockFertilizeEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + Option!(Player) player; + + /++ + + +/ + WitList!(Tuple!(BlockPos, ushort)) changedBlocks; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + changedBlocks.witFree; + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + player.witDrop; + } + + BlockFertilizeEventData witClone() const @nogc nothrow { + BlockFertilizeEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.player = this.player.witClone; + clone.changedBlocks = this.changedBlocks.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockMultiPlaceEventData { + /++ + + +/ + Player player; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + WitList!(Tuple!(BlockPos, ushort)) placedBlocks; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + placedBlocks.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + targetWorld.witDrop; + } + + BlockMultiPlaceEventData witClone() const @nogc nothrow { + BlockMultiPlaceEventData clone = void; + clone.player = this.player.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.placedBlocks = this.placedBlocks.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockReceiveGameEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + WitString gameEvent; + + /++ + + +/ + Option!(int) sourceEntityId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + gameEvent.witFree; + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + BlockReceiveGameEventData witClone() const @nogc nothrow { + BlockReceiveGameEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.gameEvent = this.gameEvent.witClone; + clone.sourceEntityId = this.sourceEntityId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockShearEntityEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + int targetEntityId; + + /++ + + +/ + ItemStack item; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + item.witDrop; + } + + BlockShearEntityEventData witClone() const @nogc nothrow { + BlockShearEntityEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.targetEntityId = this.targetEntityId.witClone; + clone.item = this.item.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BlockSpreadEventData { + /++ + + +/ + BlockPos sourcePos; + + /++ + + +/ + BlockPos targetPos; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + ushort newStateId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + BlockSpreadEventData witClone() const @nogc nothrow { + BlockSpreadEventData clone = void; + clone.sourcePos = this.sourcePos.witClone; + clone.targetPos = this.targetPos.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.newStateId = this.newStateId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct BrewingStartEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + int brewingTime; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + BrewingStartEventData witClone() const @nogc nothrow { + BrewingStartEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.brewingTime = this.brewingTime.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct CampfireStartEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + ItemStack item; + + /++ + + +/ + ubyte slot; + + /++ + + +/ + int cookingTime; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + item.witDrop; + } + + CampfireStartEventData witClone() const @nogc nothrow { + CampfireStartEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.item = this.item.witClone; + clone.slot = this.slot.witClone; + clone.cookingTime = this.cookingTime.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct CauldronLevelChangeEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + int oldLevel; + + /++ + + +/ + int newLevel; + + /++ + + +/ + WitString reason; + + /++ + + +/ + Option!(int) entityId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + reason.witFree; + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + CauldronLevelChangeEventData witClone() const @nogc nothrow { + CauldronLevelChangeEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.oldLevel = this.oldLevel.witClone; + clone.newLevel = this.newLevel.witClone; + clone.reason = this.reason.witClone; + clone.entityId = this.entityId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct CrafterCraftEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + ItemStack result; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + result.witDrop; + } + + CrafterCraftEventData witClone() const @nogc nothrow { + CrafterCraftEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.result = this.result.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EntityBlockFormEventData { + /++ + + +/ + int entityId; + + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + ushort newStateId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + EntityBlockFormEventData witClone() const @nogc nothrow { + EntityBlockFormEventData clone = void; + clone.entityId = this.entityId.witClone; + clone.blockPos = this.blockPos.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.newStateId = this.newStateId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct FluidLevelChangeEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + ushort newStateId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + FluidLevelChangeEventData witClone() const @nogc nothrow { + FluidLevelChangeEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.newStateId = this.newStateId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct InventoryBlockStartEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + World targetWorld; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + InventoryBlockStartEventData witClone() const @nogc nothrow { + InventoryBlockStartEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.targetWorld = this.targetWorld.witClone; + return clone; + } +} + +/++ + ++/ +struct LeavesDecayEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + LeavesDecayEventData witClone() const @nogc nothrow { + LeavesDecayEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct MoistureChangeEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + int newMoisture; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + MoistureChangeEventData witClone() const @nogc nothrow { + MoistureChangeEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.newMoisture = this.newMoisture.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct SculkBloomEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + int charge; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + SculkBloomEventData witClone() const @nogc nothrow { + SculkBloomEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.charge = this.charge.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct VaultDisplayItemEventData { + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + World targetWorld; + + /++ + + +/ + ItemStack item; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + item.witDrop; + } + + VaultDisplayItemEventData witClone() const @nogc nothrow { + VaultDisplayItemEventData clone = void; + clone.blockPos = this.blockPos.witClone; + clone.targetWorld = this.targetWorld.witClone; + clone.item = this.item.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct WeatherChangeEventData { + /++ + + +/ + World targetWorld; + + /++ + + +/ + bool toWeatherState; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + WeatherChangeEventData witClone() const @nogc nothrow { + WeatherChangeEventData clone = void; + clone.targetWorld = this.targetWorld.witClone; + clone.toWeatherState = this.toWeatherState.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct ThunderChangeEventData { + /++ + + +/ + World targetWorld; + + /++ + + +/ + bool toThunderState; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + ThunderChangeEventData witClone() const @nogc nothrow { + ThunderChangeEventData clone = void; + clone.targetWorld = this.targetWorld.witClone; + clone.toThunderState = this.toThunderState.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct WorldLoadEventData { + /++ + + +/ + World targetWorld; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + WorldLoadEventData witClone() const @nogc nothrow { + WorldLoadEventData clone = void; + clone.targetWorld = this.targetWorld.witClone; + return clone; + } +} + +/++ + ++/ +struct WorldUnloadEventData { + /++ + + +/ + World targetWorld; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + WorldUnloadEventData witClone() const @nogc nothrow { + WorldUnloadEventData clone = void; + clone.targetWorld = this.targetWorld.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct WorldInitEventData { + /++ + + +/ + World targetWorld; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + targetWorld.witDrop; + } + + WorldInitEventData witClone() const @nogc nothrow { + WorldInitEventData clone = void; + clone.targetWorld = this.targetWorld.witClone; + return clone; + } +} + +/++ + ++/ +struct InventoryOpenEventData { + /++ + + +/ + Player player; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + InventoryOpenEventData witClone() const @nogc nothrow { + InventoryOpenEventData clone = void; + clone.player = this.player.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct InventoryDragEventData { + /++ + + +/ + Player player; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + InventoryDragEventData witClone() const @nogc nothrow { + InventoryDragEventData clone = void; + clone.player = this.player.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct CraftItemEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString recipeId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + recipeId.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + CraftItemEventData witClone() const @nogc nothrow { + CraftItemEventData clone = void; + clone.player = this.player.witClone; + clone.recipeId = this.recipeId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct FurnaceExtractEventData { + /++ + + +/ + Player player; + + /++ + + +/ + BlockPos blockPos; + + /++ + + +/ + WitString itemId; + + /++ + + +/ + uint itemAmount; + + /++ + + +/ + float expGained; + + void witFree() @nogc nothrow { + itemId.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + FurnaceExtractEventData witClone() const @nogc nothrow { + FurnaceExtractEventData clone = void; + clone.player = this.player.witClone; + clone.blockPos = this.blockPos.witClone; + clone.itemId = this.itemId.witClone; + clone.itemAmount = this.itemAmount.witClone; + clone.expGained = this.expGained.witClone; + return clone; + } +} + +/++ + ++/ +struct InventoryCreativeEventData { + /++ + + +/ + Player player; + + /++ + + +/ + short slot; + + /++ + + +/ + WitString itemId; + + /++ + + +/ + ubyte itemCount; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + itemId.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + InventoryCreativeEventData witClone() const @nogc nothrow { + InventoryCreativeEventData clone = void; + clone.player = this.player.witClone; + clone.slot = this.slot.witClone; + clone.itemId = this.itemId.witClone; + clone.itemCount = this.itemCount.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct InventoryInteractEventData { + /++ + + +/ + Player player; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + InventoryInteractEventData witClone() const @nogc nothrow { + InventoryInteractEventData clone = void; + clone.player = this.player.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PrepareAnvilEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString renameText; + + /++ + + +/ + uint repairCost; + + void witFree() @nogc nothrow { + renameText.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PrepareAnvilEventData witClone() const @nogc nothrow { + PrepareAnvilEventData clone = void; + clone.player = this.player.witClone; + clone.renameText = this.renameText.witClone; + clone.repairCost = this.repairCost.witClone; + return clone; + } +} + +/++ + ++/ +struct PrepareGrindstoneEventData { + /++ + + +/ + Player player; + + /++ + + +/ + Option!(WitString) resultItem; + + void witFree() @nogc nothrow { + resultItem.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PrepareGrindstoneEventData witClone() const @nogc nothrow { + PrepareGrindstoneEventData clone = void; + clone.player = this.player.witClone; + clone.resultItem = this.resultItem.witClone; + return clone; + } +} + +/++ + ++/ +struct PrepareInventoryResultEventData { + /++ + + +/ + Player player; + + /++ + + +/ + Option!(WitString) resultItem; + + void witFree() @nogc nothrow { + resultItem.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PrepareInventoryResultEventData witClone() const @nogc nothrow { + PrepareInventoryResultEventData clone = void; + clone.player = this.player.witClone; + clone.resultItem = this.resultItem.witClone; + return clone; + } +} + +/++ + ++/ +struct PrepareItemCraftEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString recipeId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + recipeId.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PrepareItemCraftEventData witClone() const @nogc nothrow { + PrepareItemCraftEventData clone = void; + clone.player = this.player.witClone; + clone.recipeId = this.recipeId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PrepareSmithingEventData { + /++ + + +/ + Player player; + + /++ + + +/ + Option!(WitString) resultItem; + + void witFree() @nogc nothrow { + resultItem.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + PrepareSmithingEventData witClone() const @nogc nothrow { + PrepareSmithingEventData clone = void; + clone.player = this.player.witClone; + clone.resultItem = this.resultItem.witClone; + return clone; + } +} + +/++ + ++/ +struct SmithItemEventData { + /++ + + +/ + Player player; + + /++ + + +/ + WitString recipeId; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + recipeId.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + SmithItemEventData witClone() const @nogc nothrow { + SmithItemEventData clone = void; + clone.player = this.player.witClone; + clone.recipeId = this.recipeId.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct TradeSelectEventData { + /++ + + +/ + Player player; + + /++ + + +/ + ubyte slotIndex; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + player.witDrop; + } + + TradeSelectEventData witClone() const @nogc nothrow { + TradeSelectEventData clone = void; + clone.player = this.player.witClone; + clone.slotIndex = this.slotIndex.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct PrepareItemEnchantEventData { + /++ + + +/ + Player player; + + /++ + + +/ + ItemStack item; + + /++ + + +/ + WitList!(EnchantmentOffer) offers; + + /++ + + +/ + int bookshelfCount; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + offers.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + item.witDrop; + } + + PrepareItemEnchantEventData witClone() const @nogc nothrow { + PrepareItemEnchantEventData clone = void; + clone.player = this.player.witClone; + clone.item = this.item.witClone; + clone.offers = this.offers.witClone; + clone.bookshelfCount = this.bookshelfCount.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct EnchantItemEventData { + /++ + + +/ + Player player; + + /++ + + +/ + ItemStack item; + + /++ + + +/ + int option; + + /++ + + +/ + int cost; + + /++ + + +/ + WitList!(EnchantmentValue) enchantmentsToAdd; + + /++ + + +/ + bool cancelled; + + void witFree() @nogc nothrow { + enchantmentsToAdd.witFree; + } + + void witDrop() @nogc nothrow { + player.witDrop; + item.witDrop; + } + + EnchantItemEventData witClone() const @nogc nothrow { + EnchantItemEventData clone = void; + clone.player = this.player.witClone; + clone.item = this.item.witClone; + clone.option = this.option.witClone; + clone.cost = this.cost.witClone; + clone.enchantmentsToAdd = this.enchantmentsToAdd.witClone; + clone.cancelled = this.cancelled.witClone; + return clone; + } +} + +/++ + ++/ +struct Event { + mixin WitVariant!( + PlayerJoinEventData, // playerJoinEvent + PlayerLeaveEventData, // playerLeaveEvent + PlayerLoginEventData, // playerLoginEvent + PlayerChatEventData, // playerChatEvent + PlayerCommandSendEventData, // playerCommandSendEvent + PlayerPermissionCheckEventData, // playerPermissionCheckEvent + PlayerMoveEventData, // playerMoveEvent + PlayerTeleportEventData, // playerTeleportEvent + PlayerChangeWorldEventData, // playerChangeWorldEvent + PlayerRespawnEventData, // playerRespawnEvent + PlayerExpChangeEventData, // playerExpChangeEvent + PlayerItemHeldEventData, // playerItemHeldEvent + PlayerChangedMainHandEventData, // playerChangedMainHandEvent + PlayerGamemodeChangeEventData, // playerGamemodeChangeEvent + PlayerCustomPayloadEventData, // playerCustomPayloadEvent + PlayerFishEventData, // playerFishEvent + PlayerEggThrowEventData, // playerEggThrowEvent + PlayerInteractUnknownEntityEventData, // playerInteractUnknownEntityEvent + PlayerInteractEntityEventData, // playerInteractEntityEvent + PlayerInteractEventData, // playerInteractEvent + PlayerToggleSneakEventData, // playerToggleSneakEvent + PlayerToggleFlightEventData, // playerToggleFlightEvent + PlayerToggleSprintEventData, // playerToggleSprintEvent + InventoryClickEventData, // inventoryClickEvent + InventoryCloseEventData, // inventoryCloseEvent + BlockRedstoneEventData, // blockRedstoneEvent + BlockBreakEventData, // blockBreakEvent + BlockBurnEventData, // blockBurnEvent + BlockCanBuildEventData, // blockCanBuildEvent + BlockGrowEventData, // blockGrowEvent + BlockPlaceEventData, // blockPlaceEvent + DialogClickActionEventData, // dialogClickActionEvent + DialogShowEventData, // dialogShowEvent + DialogClearEventData, // dialogClearEvent + BedrockFormResponseEventData, // bedrockFormResponseEvent + ServerCommandEventData, // serverCommandEvent + ServerListPingEventData, // serverListPingEvent + ServerLoadEventData, // serverLoadEvent + SpawnChangeEventData, // spawnChangeEvent + ServerBroadcastEventData, // serverBroadcastEvent + ServerTickStartEventData, // serverTickStartEvent + ServerTickEndEventData, // serverTickEndEvent + PacketReceivedEventData, // packetReceivedEvent + PacketSentEventData, // packetSentEvent + ChunkLoadEventData, // chunkLoadEvent + ChunkSaveEventData, // chunkSaveEvent + ChunkSendEventData, // chunkSendEvent + EntityDamageEventData, // entityDamageEvent + EntityDeathEventData, // entityDeathEvent + PlayerDeathEventData, // playerDeathEvent + EntitySpawnEventData, // entitySpawnEvent + EntityCombustEventData, // entityCombustEvent + EntityRegainHealthEventData, // entityRegainHealthEvent + EntityAirChangeEventData, // entityAirChangeEvent + EntityBreedEventData, // entityBreedEvent + EntityDismountEventData, // entityDismountEvent + EntityDyeEventData, // entityDyeEvent + EntityEnterLoveModeEventData, // entityEnterLoveModeEvent + EntityExplodeEventData, // entityExplodeEvent + EntityMountEventData, // entityMountEvent + EntityPickupItemEventData, // entityPickupItemEvent + EntityPortalEventData, // entityPortalEvent + EntityResurrectEventData, // entityResurrectEvent + EntityShootBowEventData, // entityShootBowEvent + EntityTameEventData, // entityTameEvent + EntityTargetEventData, // entityTargetEvent + EntityTeleportEventData, // entityTeleportEvent + EntityToggleGlideEventData, // entityToggleGlideEvent + EntityTransformEventData, // entityTransformEvent + PlayerItemConsumeEventData, // playerItemConsumeEvent + PlayerItemDamageEventData, // playerItemDamageEvent + PlayerDropItemEventData, // playerDropItemEvent + PlayerBedEnterEventData, // playerBedEnterEvent + PlayerBedLeaveEventData, // playerBedLeaveEvent + PlayerBucketEmptyEventData, // playerBucketEmptyEvent + PlayerBucketFillEventData, // playerBucketFillEvent + BlockDamageEventData, // blockDamageEvent + BlockIgniteEventData, // blockIgniteEvent + BlockFromToEventData, // blockFromToEvent + BlockFormEventData, // blockFormEvent + BlockFadeEventData, // blockFadeEvent + BlockDispenseEventData, // blockDispenseEvent + BlockExplodeEventData, // blockExplodeEvent + BlockPhysicsEventData, // blockPhysicsEvent + BlockPistonExtendEventData, // blockPistonExtendEvent + BlockPistonRetractEventData, // blockPistonRetractEvent + NotePlayEventData, // notePlayEvent + SignChangeEventData, // signChangeEvent + SpongeAbsorbEventData, // spongeAbsorbEvent + TntPrimeEventData, // tntPrimeEvent + WeatherChangeEventData, // weatherChangeEvent + ThunderChangeEventData, // thunderChangeEvent + WorldLoadEventData, // worldLoadEvent + WorldUnloadEventData, // worldUnloadEvent + AsyncStructureGenerateEventData, // asyncStructureGenerateEvent + AsyncStructureSpawnEventData, // asyncStructureSpawnEvent + ChunkPopulateEventData, // chunkPopulateEvent + ChunkUnloadEventData, // chunkUnloadEvent + EntitiesLoadEventData, // entitiesLoadEvent + EntitiesUnloadEventData, // entitiesUnloadEvent + GenericGameEventData, // genericGameEvent + LootGenerateEventData, // lootGenerateEvent + PortalCreateEventData, // portalCreateEvent + StructureGrowEventData, // structureGrowEvent + TimeSkipEventData, // timeSkipEvent + WorldInitEventData, // worldInitEvent + WorldSaveEventData, // worldSaveEvent + InventoryOpenEventData, // inventoryOpenEvent + InventoryDragEventData, // inventoryDragEvent + CraftItemEventData, // craftItemEvent + FurnaceSmeltEventData, // furnaceSmeltEvent + BrewEventData, // brewEvent + BrewingStandFuelEventData, // brewingStandFuelEvent + FurnaceBurnEventData, // furnaceBurnEvent + FurnaceExtractEventData, // furnaceExtractEvent + FurnaceStartSmeltEventData, // furnaceStartSmeltEvent + HopperInventorySearchEventData, // hopperInventorySearchEvent + InventoryCreativeEventData, // inventoryCreativeEvent + InventoryInteractEventData, // inventoryInteractEvent + InventoryMoveItemEventData, // inventoryMoveItemEvent + InventoryPickupItemEventData, // inventoryPickupItemEvent + PrepareAnvilEventData, // prepareAnvilEvent + PrepareGrindstoneEventData, // prepareGrindstoneEvent + PrepareInventoryResultEventData, // prepareInventoryResultEvent + PrepareItemCraftEventData, // prepareItemCraftEvent + PrepareSmithingEventData, // prepareSmithingEvent + SmithItemEventData, // smithItemEvent + TradeSelectEventData, // tradeSelectEvent + VehicleBlockCollisionEventData, // vehicleBlockCollisionEvent + VehicleCollisionEventData, // vehicleCollisionEvent + VehicleCreateEventData, // vehicleCreateEvent + VehicleDamageEventData, // vehicleDamageEvent + VehicleDestroyEventData, // vehicleDestroyEvent + VehicleEnterEventData, // vehicleEnterEvent + VehicleEntityCollisionEventData, // vehicleEntityCollisionEvent + VehicleExitEventData, // vehicleExitEvent + VehicleMoveEventData, // vehicleMoveEvent + VehicleUpdateEventData, // vehicleUpdateEvent + PrepareItemEnchantEventData, // prepareItemEnchantEvent + EnchantItemEventData, // enchantItemEvent + MapInitializeEventData, // mapInitializeEvent + HangingBreakEventData, // hangingBreakEvent + HangingBreakByEntityEventData, // hangingBreakByEntityEvent + HangingPlaceEventData, // hangingPlaceEvent + BellResonateEventData, // bellResonateEvent + BellRingEventData, // bellRingEvent + BlockBrushEventData, // blockBrushEvent + BlockCookEventData, // blockCookEvent + BlockDamageAbortEventData, // blockDamageAbortEvent + BlockDispenseArmorEventData, // blockDispenseArmorEvent + BlockDispenseLootEventData, // blockDispenseLootEvent + BlockDropItemEventData, // blockDropItemEvent + BlockExpEventData, // blockExpEvent + BlockFertilizeEventData, // blockFertilizeEvent + BlockMultiPlaceEventData, // blockMultiPlaceEvent + BlockReceiveGameEventData, // blockReceiveGameEvent + BlockShearEntityEventData, // blockShearEntityEvent + BlockSpreadEventData, // blockSpreadEvent + BrewingStartEventData, // brewingStartEvent + CampfireStartEventData, // campfireStartEvent + CauldronLevelChangeEventData, // cauldronLevelChangeEvent + CrafterCraftEventData, // crafterCraftEvent + EntityBlockFormEventData, // entityBlockFormEvent + FluidLevelChangeEventData, // fluidLevelChangeEvent + InventoryBlockStartEventData, // inventoryBlockStartEvent + LeavesDecayEventData, // leavesDecayEvent + MoistureChangeEventData, // moistureChangeEvent + SculkBloomEventData, // sculkBloomEvent + VaultDisplayItemEventData, // vaultDisplayItemEvent + CreatureSpawnEventData, // creatureSpawnEvent + EnderDragonChangePhaseEventData, // enderDragonChangePhaseEvent + EntityBreakDoorEventData, // entityBreakDoorEvent + EntityChangeBlockEventData, // entityChangeBlockEvent + EntityDamageByBlockEventData, // entityDamageByBlockEvent + EntityDamageByEntityEventData, // entityDamageByEntityEvent + EntityDropItemEventData, // entityDropItemEvent + EntityEnterBlockEventData, // entityEnterBlockEvent + EntityExhaustionEventData, // entityExhaustionEvent + EntityInteractEventData, // entityInteractEvent + EntityKnockbackEventData, // entityKnockbackEvent + EntityPlaceEventData, // entityPlaceEvent + EntityPoseChangeEventData, // entityPoseChangeEvent + EntityPotionEffectEventData, // entityPotionEffectEvent + EntitySpellCastEventData, // entitySpellCastEvent + EntityTargetLivingEntityEventData, // entityTargetLivingEntityEvent + EntityToggleSwimEventData, // entityToggleSwimEvent + ExplosionPrimeEventData, // explosionPrimeEvent + FireworkExplodeEventData, // fireworkExplodeEvent + FoodLevelChangeEventData, // foodLevelChangeEvent + ItemDespawnEventData, // itemDespawnEvent + ItemMergeEventData, // itemMergeEvent + ItemSpawnEventData, // itemSpawnEvent + PiglinBarterEventData, // piglinBarterEvent + ProjectileHitEventData, // projectileHitEvent + ProjectileLaunchEventData, // projectileLaunchEvent + SheepDyeWoolEventData, // sheepDyeWoolEvent + SheepRegrowWoolEventData, // sheepRegrowWoolEvent + SlimeSplitEventData, // slimeSplitEvent + StriderTemperatureChangeEventData, // striderTemperatureChangeEvent + VillagerAcquireTradeEventData, // villagerAcquireTradeEvent + VillagerCareerChangeEventData, // villagerCareerChangeEvent + VillagerReplenishTradeEventData, // villagerReplenishTradeEvent + WardenAngerChangeEventData, // wardenAngerChangeEvent + AreaEffectCloudApplyEventData, // areaEffectCloudApplyEvent + ArrowBodyCountChangeEventData, // arrowBodyCountChangeEvent + BatToggleSleepEventData, // batToggleSleepEvent + CreeperPowerEventData, // creeperPowerEvent + EntityCombustByBlockEventData, // entityCombustByBlockEvent + EntityCombustByEntityEventData, // entityCombustByEntityEvent + EntityKnockbackByEntityEventData, // entityKnockbackByEntityEvent + EntityPortalEnterEventData, // entityPortalEnterEvent + EntityPortalExitEventData, // entityPortalExitEvent + EntityRemoveEventData, // entityRemoveEvent + EntityTargetBlockEventData, // entityTargetBlockEvent + EntityUnleashEventData, // entityUnleashEvent + ExpBottleEventData, // expBottleEvent + HorseJumpEventData, // horseJumpEvent + LingeringPotionSplashEventData, // lingeringPotionSplashEvent + PigZapEventData, // pigZapEvent + PigZombieAngerEventData, // pigZombieAngerEvent + PotionSplashEventData, // potionSplashEvent + SpawnerSpawnEventData, // spawnerSpawnEvent + TrialSpawnerSpawnEventData, // trialSpawnerSpawnEvent + VillagerReputationChangeEventData, // villagerReputationChangeEvent + AsyncPlayerChatEventData, // asyncPlayerChatEvent + AsyncPlayerPreLoginEventData, // asyncPlayerPreLoginEvent + PlayerAdvancementDoneEventData, // playerAdvancementDoneEvent + PlayerAnimationEventData, // playerAnimationEvent + PlayerArmorStandManipulateEventData, // playerArmorStandManipulateEvent + PlayerBucketEntityEventData, // playerBucketEntityEvent + PlayerChangedWorldEventData, // playerChangedWorldEvent + PlayerChannelEventData, // playerChannelEvent + PlayerCommandPreprocessEventData, // playerCommandPreprocessEvent + PlayerEditBookEventData, // playerEditBookEvent + PlayerElytraBoostEventData, // playerElytraBoostEvent + PlayerExpCooldownChangeEventData, // playerExpCooldownChangeEvent + PlayerHarvestBlockEventData, // playerHarvestBlockEvent + PlayerHideEntityEventData, // playerHideEntityEvent + PlayerItemBreakEventData, // playerItemBreakEvent + PlayerItemMendEventData, // playerItemMendEvent + PlayerKickEventData, // playerKickEvent + PlayerLeashEntityEventData, // playerLeashEntityEvent + PlayerLevelChangeEventData, // playerLevelChangeEvent + PlayerLocaleChangeEventData, // playerLocaleChangeEvent + PlayerNameEntityEventData, // playerNameEntityEvent + PlayerOpenSignEventData, // playerOpenSignEvent + PlayerPortalEventData, // playerPortalEvent + PlayerPreLoginEventData, // playerPreLoginEvent + PlayerRiptideEventData, // playerRiptideEvent + PlayerShearEntityEventData, // playerShearEntityEvent + PlayerShowEntityEventData, // playerShowEntityEvent + PlayerSpawnChangeEventData, // playerSpawnChangeEvent + PlayerStatisticIncrementEventData, // playerStatisticIncrementEvent + PlayerSwapHandsEventData, // playerSwapHandsEvent + PlayerTakeLecternBookEventData, // playerTakeLecternBookEvent + PlayerUnleashEntityEventData, // playerUnleashEntityEvent + PlayerVelocityEventData, // playerVelocityEvent + PlayerInputEventData, // playerInputEvent + PlayerInteractAtEntityEventData, // playerInteractAtEntityEvent + PlayerLinksSendEventData, // playerLinksSendEvent + PlayerPickupArrowEventData, // playerPickupArrowEvent + PlayerRecipeBookClickEventData, // playerRecipeBookClickEvent + PlayerRecipeBookSettingsChangeEventData, // playerRecipeBookSettingsChangeEvent + PlayerRecipeDiscoverEventData, // playerRecipeDiscoverEvent + PlayerRegisterChannelEventData, // playerRegisterChannelEvent + PlayerResourcePackStatusEventData, // playerResourcePackStatusEvent + PlayerSpawnLocationEventData, // playerSpawnLocationEvent + PlayerUnregisterChannelEventData, // playerUnregisterChannelEvent + RaidFinishEventData, // raidFinishEvent + RaidSpawnWaveEventData, // raidSpawnWaveEvent + RaidStopEventData, // raidStopEvent + RaidTriggerEventData, // raidTriggerEvent + LightningStrikeEventData, // lightningStrikeEvent + ); + +public: + enum Tag : ushort { + /++ + + +/ + playerJoinEvent, + + /++ + + +/ + playerLeaveEvent, + + /++ + + +/ + playerLoginEvent, + + /++ + + +/ + playerChatEvent, + + /++ + + +/ + playerCommandSendEvent, + + /++ + + +/ + playerPermissionCheckEvent, + + /++ + + +/ + playerMoveEvent, + + /++ + + +/ + playerTeleportEvent, + + /++ + + +/ + playerChangeWorldEvent, + + /++ + + +/ + playerRespawnEvent, + + /++ + + +/ + playerExpChangeEvent, + + /++ + + +/ + playerItemHeldEvent, + + /++ + + +/ + playerChangedMainHandEvent, + + /++ + + +/ + playerGamemodeChangeEvent, + + /++ + + +/ + playerCustomPayloadEvent, + + /++ + + +/ + playerFishEvent, + + /++ + + +/ + playerEggThrowEvent, + + /++ + + +/ + playerInteractUnknownEntityEvent, + + /++ + + +/ + playerInteractEntityEvent, + + /++ + + +/ + playerInteractEvent, + + /++ + + +/ + playerToggleSneakEvent, + + /++ + + +/ + playerToggleFlightEvent, + + /++ + + +/ + playerToggleSprintEvent, + + /++ + + +/ + inventoryClickEvent, + + /++ + + +/ + inventoryCloseEvent, + + /++ + + +/ + blockRedstoneEvent, + + /++ + + +/ + blockBreakEvent, + + /++ + + +/ + blockBurnEvent, + + /++ + + +/ + blockCanBuildEvent, + + /++ + + +/ + blockGrowEvent, + + /++ + + +/ + blockPlaceEvent, + + /++ + + +/ + dialogClickActionEvent, + + /++ + + +/ + dialogShowEvent, + + /++ + + +/ + dialogClearEvent, + + /++ + + +/ + bedrockFormResponseEvent, + + /++ + + +/ + serverCommandEvent, + + /++ + + +/ + serverListPingEvent, + + /++ + + +/ + serverLoadEvent, + + /++ + + +/ + spawnChangeEvent, + + /++ + + +/ + serverBroadcastEvent, + + /++ + + +/ + serverTickStartEvent, + + /++ + + +/ + serverTickEndEvent, + + /++ + + +/ + packetReceivedEvent, + + /++ + + +/ + packetSentEvent, + + /++ + + +/ + chunkLoadEvent, + + /++ + + +/ + chunkSaveEvent, + + /++ + + +/ + chunkSendEvent, + + /++ + + +/ + entityDamageEvent, + + /++ + + +/ + entityDeathEvent, + + /++ + + +/ + playerDeathEvent, + + /++ + + +/ + entitySpawnEvent, + + /++ + + +/ + entityCombustEvent, + + /++ + + +/ + entityRegainHealthEvent, + + /++ + + +/ + entityAirChangeEvent, + + /++ + + +/ + entityBreedEvent, + + /++ + + +/ + entityDismountEvent, + + /++ + + +/ + entityDyeEvent, + + /++ + + +/ + entityEnterLoveModeEvent, + + /++ + + +/ + entityExplodeEvent, + + /++ + + +/ + entityMountEvent, + + /++ + + +/ + entityPickupItemEvent, + + /++ + + +/ + entityPortalEvent, + + /++ + + +/ + entityResurrectEvent, + + /++ + + +/ + entityShootBowEvent, + + /++ + + +/ + entityTameEvent, + + /++ + + +/ + entityTargetEvent, + + /++ + + +/ + entityTeleportEvent, + + /++ + + +/ + entityToggleGlideEvent, + + /++ + + +/ + entityTransformEvent, + + /++ + + +/ + playerItemConsumeEvent, + + /++ + + +/ + playerItemDamageEvent, + + /++ + + +/ + playerDropItemEvent, + + /++ + + +/ + playerBedEnterEvent, + + /++ + + +/ + playerBedLeaveEvent, + + /++ + + +/ + playerBucketEmptyEvent, + + /++ + + +/ + playerBucketFillEvent, + + /++ + + +/ + blockDamageEvent, + + /++ + + +/ + blockIgniteEvent, + + /++ + + +/ + blockFromToEvent, + + /++ + + +/ + blockFormEvent, + + /++ + + +/ + blockFadeEvent, + + /++ + + +/ + blockDispenseEvent, + + /++ + + +/ + blockExplodeEvent, + + /++ + + +/ + blockPhysicsEvent, + + /++ + + +/ + blockPistonExtendEvent, + + /++ + + +/ + blockPistonRetractEvent, + + /++ + + +/ + notePlayEvent, + + /++ + + +/ + signChangeEvent, + + /++ + + +/ + spongeAbsorbEvent, + + /++ + + +/ + tntPrimeEvent, + + /++ + + +/ + weatherChangeEvent, + + /++ + + +/ + thunderChangeEvent, + + /++ + + +/ + worldLoadEvent, + + /++ + + +/ + worldUnloadEvent, + + /++ + + +/ + asyncStructureGenerateEvent, + + /++ + + +/ + asyncStructureSpawnEvent, + + /++ + + +/ + chunkPopulateEvent, + + /++ + + +/ + chunkUnloadEvent, + + /++ + + +/ + entitiesLoadEvent, + + /++ + + +/ + entitiesUnloadEvent, + + /++ + + +/ + genericGameEvent, + + /++ + + +/ + lootGenerateEvent, + + /++ + + +/ + portalCreateEvent, + + /++ + + +/ + structureGrowEvent, + + /++ + + +/ + timeSkipEvent, + + /++ + + +/ + worldInitEvent, + + /++ + + +/ + worldSaveEvent, + + /++ + + +/ + inventoryOpenEvent, + + /++ + + +/ + inventoryDragEvent, + + /++ + + +/ + craftItemEvent, + + /++ + + +/ + furnaceSmeltEvent, + + /++ + + +/ + brewEvent, + + /++ + + +/ + brewingStandFuelEvent, + + /++ + + +/ + furnaceBurnEvent, + + /++ + + +/ + furnaceExtractEvent, + + /++ + + +/ + furnaceStartSmeltEvent, + + /++ + + +/ + hopperInventorySearchEvent, + + /++ + + +/ + inventoryCreativeEvent, + + /++ + + +/ + inventoryInteractEvent, + + /++ + + +/ + inventoryMoveItemEvent, + + /++ + + +/ + inventoryPickupItemEvent, + + /++ + + +/ + prepareAnvilEvent, + + /++ + + +/ + prepareGrindstoneEvent, + + /++ + + +/ + prepareInventoryResultEvent, + + /++ + + +/ + prepareItemCraftEvent, + + /++ + + +/ + prepareSmithingEvent, + + /++ + + +/ + smithItemEvent, + + /++ + + +/ + tradeSelectEvent, + + /++ + + +/ + vehicleBlockCollisionEvent, + + /++ + + +/ + vehicleCollisionEvent, + + /++ + + +/ + vehicleCreateEvent, + + /++ + + +/ + vehicleDamageEvent, + + /++ + + +/ + vehicleDestroyEvent, + + /++ + + +/ + vehicleEnterEvent, + + /++ + + +/ + vehicleEntityCollisionEvent, + + /++ + + +/ + vehicleExitEvent, + + /++ + + +/ + vehicleMoveEvent, + + /++ + + +/ + vehicleUpdateEvent, + + /++ + + +/ + prepareItemEnchantEvent, + + /++ + + +/ + enchantItemEvent, + + /++ + + +/ + mapInitializeEvent, + + /++ + + +/ + hangingBreakEvent, + + /++ + + +/ + hangingBreakByEntityEvent, + + /++ + + +/ + hangingPlaceEvent, + + /++ + + +/ + bellResonateEvent, + + /++ + + +/ + bellRingEvent, + + /++ + + +/ + blockBrushEvent, + + /++ + + +/ + blockCookEvent, + + /++ + + +/ + blockDamageAbortEvent, + + /++ + + +/ + blockDispenseArmorEvent, + + /++ + + +/ + blockDispenseLootEvent, + + /++ + + +/ + blockDropItemEvent, + + /++ + + +/ + blockExpEvent, + + /++ + + +/ + blockFertilizeEvent, + + /++ + + +/ + blockMultiPlaceEvent, + + /++ + + +/ + blockReceiveGameEvent, + + /++ + + +/ + blockShearEntityEvent, + + /++ + + +/ + blockSpreadEvent, + + /++ + + +/ + brewingStartEvent, + + /++ + + +/ + campfireStartEvent, + + /++ + + +/ + cauldronLevelChangeEvent, + + /++ + + +/ + crafterCraftEvent, + + /++ + + +/ + entityBlockFormEvent, + + /++ + + +/ + fluidLevelChangeEvent, + + /++ + + +/ + inventoryBlockStartEvent, + + /++ + + +/ + leavesDecayEvent, + + /++ + + +/ + moistureChangeEvent, + + /++ + + +/ + sculkBloomEvent, + + /++ + + +/ + vaultDisplayItemEvent, + + /++ + + +/ + creatureSpawnEvent, + + /++ + + +/ + enderDragonChangePhaseEvent, + + /++ + + +/ + entityBreakDoorEvent, + + /++ + + +/ + entityChangeBlockEvent, + + /++ + + +/ + entityDamageByBlockEvent, + + /++ + + +/ + entityDamageByEntityEvent, + + /++ + + +/ + entityDropItemEvent, + + /++ + + +/ + entityEnterBlockEvent, + + /++ + + +/ + entityExhaustionEvent, + + /++ + + +/ + entityInteractEvent, + + /++ + + +/ + entityKnockbackEvent, + + /++ + + +/ + entityPlaceEvent, + + /++ + + +/ + entityPoseChangeEvent, + + /++ + + +/ + entityPotionEffectEvent, + + /++ + + +/ + entitySpellCastEvent, + + /++ + + +/ + entityTargetLivingEntityEvent, + + /++ + + +/ + entityToggleSwimEvent, + + /++ + + +/ + explosionPrimeEvent, + + /++ + + +/ + fireworkExplodeEvent, + + /++ + + +/ + foodLevelChangeEvent, + + /++ + + +/ + itemDespawnEvent, + + /++ + + +/ + itemMergeEvent, + + /++ + + +/ + itemSpawnEvent, + + /++ + + +/ + piglinBarterEvent, + + /++ + + +/ + projectileHitEvent, + + /++ + + +/ + projectileLaunchEvent, + + /++ + + +/ + sheepDyeWoolEvent, + + /++ + + +/ + sheepRegrowWoolEvent, + + /++ + + +/ + slimeSplitEvent, + + /++ + + +/ + striderTemperatureChangeEvent, + + /++ + + +/ + villagerAcquireTradeEvent, + + /++ + + +/ + villagerCareerChangeEvent, + + /++ + + +/ + villagerReplenishTradeEvent, + + /++ + + +/ + wardenAngerChangeEvent, + + /++ + + +/ + areaEffectCloudApplyEvent, + + /++ + + +/ + arrowBodyCountChangeEvent, + + /++ + + +/ + batToggleSleepEvent, + + /++ + + +/ + creeperPowerEvent, + + /++ + + +/ + entityCombustByBlockEvent, + + /++ + + +/ + entityCombustByEntityEvent, + + /++ + + +/ + entityKnockbackByEntityEvent, + + /++ + + +/ + entityPortalEnterEvent, + + /++ + + +/ + entityPortalExitEvent, + + /++ + + +/ + entityRemoveEvent, + + /++ + + +/ + entityTargetBlockEvent, + + /++ + + +/ + entityUnleashEvent, + + /++ + + +/ + expBottleEvent, + + /++ + + +/ + horseJumpEvent, + + /++ + + +/ + lingeringPotionSplashEvent, + + /++ + + +/ + pigZapEvent, + + /++ + + +/ + pigZombieAngerEvent, + + /++ + + +/ + potionSplashEvent, + + /++ + + +/ + spawnerSpawnEvent, + + /++ + + +/ + trialSpawnerSpawnEvent, + + /++ + + +/ + villagerReputationChangeEvent, + + /++ + + +/ + asyncPlayerChatEvent, + + /++ + + +/ + asyncPlayerPreLoginEvent, + + /++ + + +/ + playerAdvancementDoneEvent, + + /++ + + +/ + playerAnimationEvent, + + /++ + + +/ + playerArmorStandManipulateEvent, + + /++ + + +/ + playerBucketEntityEvent, + + /++ + + +/ + playerChangedWorldEvent, + + /++ + + +/ + playerChannelEvent, + + /++ + + +/ + playerCommandPreprocessEvent, + + /++ + + +/ + playerEditBookEvent, + + /++ + + +/ + playerElytraBoostEvent, + + /++ + + +/ + playerExpCooldownChangeEvent, + + /++ + + +/ + playerHarvestBlockEvent, + + /++ + + +/ + playerHideEntityEvent, + + /++ + + +/ + playerItemBreakEvent, + + /++ + + +/ + playerItemMendEvent, + + /++ + + +/ + playerKickEvent, + + /++ + + +/ + playerLeashEntityEvent, + + /++ + + +/ + playerLevelChangeEvent, + + /++ + + +/ + playerLocaleChangeEvent, + + /++ + + +/ + playerNameEntityEvent, + + /++ + + +/ + playerOpenSignEvent, + + /++ + + +/ + playerPortalEvent, + + /++ + + +/ + playerPreLoginEvent, + + /++ + + +/ + playerRiptideEvent, + + /++ + + +/ + playerShearEntityEvent, + + /++ + + +/ + playerShowEntityEvent, + + /++ + + +/ + playerSpawnChangeEvent, + + /++ + + +/ + playerStatisticIncrementEvent, + + /++ + + +/ + playerSwapHandsEvent, + + /++ + + +/ + playerTakeLecternBookEvent, + + /++ + + +/ + playerUnleashEntityEvent, + + /++ + + +/ + playerVelocityEvent, + + /++ + + +/ + playerInputEvent, + + /++ + + +/ + playerInteractAtEntityEvent, + + /++ + + +/ + playerLinksSendEvent, + + /++ + + +/ + playerPickupArrowEvent, + + /++ + + +/ + playerRecipeBookClickEvent, + + /++ + + +/ + playerRecipeBookSettingsChangeEvent, + + /++ + + +/ + playerRecipeDiscoverEvent, + + /++ + + +/ + playerRegisterChannelEvent, + + /++ + + +/ + playerResourcePackStatusEvent, + + /++ + + +/ + playerSpawnLocationEvent, + + /++ + + +/ + playerUnregisterChannelEvent, + + /++ + + +/ + raidFinishEvent, + + /++ + + +/ + raidSpawnWaveEvent, + + /++ + + +/ + raidStopEvent, + + /++ + + +/ + raidTriggerEvent, + + /++ + + +/ + lightningStrikeEvent, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias playerJoinEvent = _create!(Tag.playerJoinEvent); + /// ditto + pragma(inline, true) bool isPlayerJoinEvent() const => _tag == Tag.playerJoinEvent; + ///ditto + alias getPlayerJoinEvent = _get!(Tag.playerJoinEvent); + + /++ + + +/ + alias playerLeaveEvent = _create!(Tag.playerLeaveEvent); + /// ditto + pragma(inline, true) bool isPlayerLeaveEvent() const => _tag == Tag.playerLeaveEvent; + ///ditto + alias getPlayerLeaveEvent = _get!(Tag.playerLeaveEvent); + + /++ + + +/ + alias playerLoginEvent = _create!(Tag.playerLoginEvent); + /// ditto + pragma(inline, true) bool isPlayerLoginEvent() const => _tag == Tag.playerLoginEvent; + ///ditto + alias getPlayerLoginEvent = _get!(Tag.playerLoginEvent); + + /++ + + +/ + alias playerChatEvent = _create!(Tag.playerChatEvent); + /// ditto + pragma(inline, true) bool isPlayerChatEvent() const => _tag == Tag.playerChatEvent; + ///ditto + alias getPlayerChatEvent = _get!(Tag.playerChatEvent); + + /++ + + +/ + alias playerCommandSendEvent = _create!(Tag.playerCommandSendEvent); + /// ditto + pragma(inline, true) bool isPlayerCommandSendEvent() const => _tag == Tag.playerCommandSendEvent; + ///ditto + alias getPlayerCommandSendEvent = _get!(Tag.playerCommandSendEvent); + + /++ + + +/ + alias playerPermissionCheckEvent = _create!(Tag.playerPermissionCheckEvent); + /// ditto + pragma(inline, true) bool isPlayerPermissionCheckEvent() const => _tag == Tag.playerPermissionCheckEvent; + ///ditto + alias getPlayerPermissionCheckEvent = _get!(Tag.playerPermissionCheckEvent); + + /++ + + +/ + alias playerMoveEvent = _create!(Tag.playerMoveEvent); + /// ditto + pragma(inline, true) bool isPlayerMoveEvent() const => _tag == Tag.playerMoveEvent; + ///ditto + alias getPlayerMoveEvent = _get!(Tag.playerMoveEvent); + + /++ + + +/ + alias playerTeleportEvent = _create!(Tag.playerTeleportEvent); + /// ditto + pragma(inline, true) bool isPlayerTeleportEvent() const => _tag == Tag.playerTeleportEvent; + ///ditto + alias getPlayerTeleportEvent = _get!(Tag.playerTeleportEvent); + + /++ + + +/ + alias playerChangeWorldEvent = _create!(Tag.playerChangeWorldEvent); + /// ditto + pragma(inline, true) bool isPlayerChangeWorldEvent() const => _tag == Tag.playerChangeWorldEvent; + ///ditto + alias getPlayerChangeWorldEvent = _get!(Tag.playerChangeWorldEvent); + + /++ + + +/ + alias playerRespawnEvent = _create!(Tag.playerRespawnEvent); + /// ditto + pragma(inline, true) bool isPlayerRespawnEvent() const => _tag == Tag.playerRespawnEvent; + ///ditto + alias getPlayerRespawnEvent = _get!(Tag.playerRespawnEvent); + + /++ + + +/ + alias playerExpChangeEvent = _create!(Tag.playerExpChangeEvent); + /// ditto + pragma(inline, true) bool isPlayerExpChangeEvent() const => _tag == Tag.playerExpChangeEvent; + ///ditto + alias getPlayerExpChangeEvent = _get!(Tag.playerExpChangeEvent); + + /++ + + +/ + alias playerItemHeldEvent = _create!(Tag.playerItemHeldEvent); + /// ditto + pragma(inline, true) bool isPlayerItemHeldEvent() const => _tag == Tag.playerItemHeldEvent; + ///ditto + alias getPlayerItemHeldEvent = _get!(Tag.playerItemHeldEvent); + + /++ + + +/ + alias playerChangedMainHandEvent = _create!(Tag.playerChangedMainHandEvent); + /// ditto + pragma(inline, true) bool isPlayerChangedMainHandEvent() const => _tag == Tag.playerChangedMainHandEvent; + ///ditto + alias getPlayerChangedMainHandEvent = _get!(Tag.playerChangedMainHandEvent); + + /++ + + +/ + alias playerGamemodeChangeEvent = _create!(Tag.playerGamemodeChangeEvent); + /// ditto + pragma(inline, true) bool isPlayerGamemodeChangeEvent() const => _tag == Tag.playerGamemodeChangeEvent; + ///ditto + alias getPlayerGamemodeChangeEvent = _get!(Tag.playerGamemodeChangeEvent); + + /++ + + +/ + alias playerCustomPayloadEvent = _create!(Tag.playerCustomPayloadEvent); + /// ditto + pragma(inline, true) bool isPlayerCustomPayloadEvent() const => _tag == Tag.playerCustomPayloadEvent; + ///ditto + alias getPlayerCustomPayloadEvent = _get!(Tag.playerCustomPayloadEvent); + + /++ + + +/ + alias playerFishEvent = _create!(Tag.playerFishEvent); + /// ditto + pragma(inline, true) bool isPlayerFishEvent() const => _tag == Tag.playerFishEvent; + ///ditto + alias getPlayerFishEvent = _get!(Tag.playerFishEvent); + + /++ + + +/ + alias playerEggThrowEvent = _create!(Tag.playerEggThrowEvent); + /// ditto + pragma(inline, true) bool isPlayerEggThrowEvent() const => _tag == Tag.playerEggThrowEvent; + ///ditto + alias getPlayerEggThrowEvent = _get!(Tag.playerEggThrowEvent); + + /++ + + +/ + alias playerInteractUnknownEntityEvent = _create!(Tag.playerInteractUnknownEntityEvent); + /// ditto + pragma(inline, true) bool isPlayerInteractUnknownEntityEvent() const => _tag == Tag.playerInteractUnknownEntityEvent; + ///ditto + alias getPlayerInteractUnknownEntityEvent = _get!(Tag.playerInteractUnknownEntityEvent); + + /++ + + +/ + alias playerInteractEntityEvent = _create!(Tag.playerInteractEntityEvent); + /// ditto + pragma(inline, true) bool isPlayerInteractEntityEvent() const => _tag == Tag.playerInteractEntityEvent; + ///ditto + alias getPlayerInteractEntityEvent = _get!(Tag.playerInteractEntityEvent); + + /++ + + +/ + alias playerInteractEvent = _create!(Tag.playerInteractEvent); + /// ditto + pragma(inline, true) bool isPlayerInteractEvent() const => _tag == Tag.playerInteractEvent; + ///ditto + alias getPlayerInteractEvent = _get!(Tag.playerInteractEvent); + + /++ + + +/ + alias playerToggleSneakEvent = _create!(Tag.playerToggleSneakEvent); + /// ditto + pragma(inline, true) bool isPlayerToggleSneakEvent() const => _tag == Tag.playerToggleSneakEvent; + ///ditto + alias getPlayerToggleSneakEvent = _get!(Tag.playerToggleSneakEvent); + + /++ + + +/ + alias playerToggleFlightEvent = _create!(Tag.playerToggleFlightEvent); + /// ditto + pragma(inline, true) bool isPlayerToggleFlightEvent() const => _tag == Tag.playerToggleFlightEvent; + ///ditto + alias getPlayerToggleFlightEvent = _get!(Tag.playerToggleFlightEvent); + + /++ + + +/ + alias playerToggleSprintEvent = _create!(Tag.playerToggleSprintEvent); + /// ditto + pragma(inline, true) bool isPlayerToggleSprintEvent() const => _tag == Tag.playerToggleSprintEvent; + ///ditto + alias getPlayerToggleSprintEvent = _get!(Tag.playerToggleSprintEvent); + + /++ + + +/ + alias inventoryClickEvent = _create!(Tag.inventoryClickEvent); + /// ditto + pragma(inline, true) bool isInventoryClickEvent() const => _tag == Tag.inventoryClickEvent; + ///ditto + alias getInventoryClickEvent = _get!(Tag.inventoryClickEvent); + + /++ + + +/ + alias inventoryCloseEvent = _create!(Tag.inventoryCloseEvent); + /// ditto + pragma(inline, true) bool isInventoryCloseEvent() const => _tag == Tag.inventoryCloseEvent; + ///ditto + alias getInventoryCloseEvent = _get!(Tag.inventoryCloseEvent); + + /++ + + +/ + alias blockRedstoneEvent = _create!(Tag.blockRedstoneEvent); + /// ditto + pragma(inline, true) bool isBlockRedstoneEvent() const => _tag == Tag.blockRedstoneEvent; + ///ditto + alias getBlockRedstoneEvent = _get!(Tag.blockRedstoneEvent); + + /++ + + +/ + alias blockBreakEvent = _create!(Tag.blockBreakEvent); + /// ditto + pragma(inline, true) bool isBlockBreakEvent() const => _tag == Tag.blockBreakEvent; + ///ditto + alias getBlockBreakEvent = _get!(Tag.blockBreakEvent); + + /++ + + +/ + alias blockBurnEvent = _create!(Tag.blockBurnEvent); + /// ditto + pragma(inline, true) bool isBlockBurnEvent() const => _tag == Tag.blockBurnEvent; + ///ditto + alias getBlockBurnEvent = _get!(Tag.blockBurnEvent); + + /++ + + +/ + alias blockCanBuildEvent = _create!(Tag.blockCanBuildEvent); + /// ditto + pragma(inline, true) bool isBlockCanBuildEvent() const => _tag == Tag.blockCanBuildEvent; + ///ditto + alias getBlockCanBuildEvent = _get!(Tag.blockCanBuildEvent); + + /++ + + +/ + alias blockGrowEvent = _create!(Tag.blockGrowEvent); + /// ditto + pragma(inline, true) bool isBlockGrowEvent() const => _tag == Tag.blockGrowEvent; + ///ditto + alias getBlockGrowEvent = _get!(Tag.blockGrowEvent); + + /++ + + +/ + alias blockPlaceEvent = _create!(Tag.blockPlaceEvent); + /// ditto + pragma(inline, true) bool isBlockPlaceEvent() const => _tag == Tag.blockPlaceEvent; + ///ditto + alias getBlockPlaceEvent = _get!(Tag.blockPlaceEvent); + + /++ + + +/ + alias dialogClickActionEvent = _create!(Tag.dialogClickActionEvent); + /// ditto + pragma(inline, true) bool isDialogClickActionEvent() const => _tag == Tag.dialogClickActionEvent; + ///ditto + alias getDialogClickActionEvent = _get!(Tag.dialogClickActionEvent); + + /++ + + +/ + alias dialogShowEvent = _create!(Tag.dialogShowEvent); + /// ditto + pragma(inline, true) bool isDialogShowEvent() const => _tag == Tag.dialogShowEvent; + ///ditto + alias getDialogShowEvent = _get!(Tag.dialogShowEvent); + + /++ + + +/ + alias dialogClearEvent = _create!(Tag.dialogClearEvent); + /// ditto + pragma(inline, true) bool isDialogClearEvent() const => _tag == Tag.dialogClearEvent; + ///ditto + alias getDialogClearEvent = _get!(Tag.dialogClearEvent); + + /++ + + +/ + alias bedrockFormResponseEvent = _create!(Tag.bedrockFormResponseEvent); + /// ditto + pragma(inline, true) bool isBedrockFormResponseEvent() const => _tag == Tag.bedrockFormResponseEvent; + ///ditto + alias getBedrockFormResponseEvent = _get!(Tag.bedrockFormResponseEvent); + + /++ + + +/ + alias serverCommandEvent = _create!(Tag.serverCommandEvent); + /// ditto + pragma(inline, true) bool isServerCommandEvent() const => _tag == Tag.serverCommandEvent; + ///ditto + alias getServerCommandEvent = _get!(Tag.serverCommandEvent); + + /++ + + +/ + alias serverListPingEvent = _create!(Tag.serverListPingEvent); + /// ditto + pragma(inline, true) bool isServerListPingEvent() const => _tag == Tag.serverListPingEvent; + ///ditto + alias getServerListPingEvent = _get!(Tag.serverListPingEvent); + + /++ + + +/ + alias serverLoadEvent = _create!(Tag.serverLoadEvent); + /// ditto + pragma(inline, true) bool isServerLoadEvent() const => _tag == Tag.serverLoadEvent; + ///ditto + alias getServerLoadEvent = _get!(Tag.serverLoadEvent); + + /++ + + +/ + alias spawnChangeEvent = _create!(Tag.spawnChangeEvent); + /// ditto + pragma(inline, true) bool isSpawnChangeEvent() const => _tag == Tag.spawnChangeEvent; + ///ditto + alias getSpawnChangeEvent = _get!(Tag.spawnChangeEvent); + + /++ + + +/ + alias serverBroadcastEvent = _create!(Tag.serverBroadcastEvent); + /// ditto + pragma(inline, true) bool isServerBroadcastEvent() const => _tag == Tag.serverBroadcastEvent; + ///ditto + alias getServerBroadcastEvent = _get!(Tag.serverBroadcastEvent); + + /++ + + +/ + alias serverTickStartEvent = _create!(Tag.serverTickStartEvent); + /// ditto + pragma(inline, true) bool isServerTickStartEvent() const => _tag == Tag.serverTickStartEvent; + ///ditto + alias getServerTickStartEvent = _get!(Tag.serverTickStartEvent); + + /++ + + +/ + alias serverTickEndEvent = _create!(Tag.serverTickEndEvent); + /// ditto + pragma(inline, true) bool isServerTickEndEvent() const => _tag == Tag.serverTickEndEvent; + ///ditto + alias getServerTickEndEvent = _get!(Tag.serverTickEndEvent); + + /++ + + +/ + alias packetReceivedEvent = _create!(Tag.packetReceivedEvent); + /// ditto + pragma(inline, true) bool isPacketReceivedEvent() const => _tag == Tag.packetReceivedEvent; + ///ditto + alias getPacketReceivedEvent = _get!(Tag.packetReceivedEvent); + + /++ + + +/ + alias packetSentEvent = _create!(Tag.packetSentEvent); + /// ditto + pragma(inline, true) bool isPacketSentEvent() const => _tag == Tag.packetSentEvent; + ///ditto + alias getPacketSentEvent = _get!(Tag.packetSentEvent); + + /++ + + +/ + alias chunkLoadEvent = _create!(Tag.chunkLoadEvent); + /// ditto + pragma(inline, true) bool isChunkLoadEvent() const => _tag == Tag.chunkLoadEvent; + ///ditto + alias getChunkLoadEvent = _get!(Tag.chunkLoadEvent); + + /++ + + +/ + alias chunkSaveEvent = _create!(Tag.chunkSaveEvent); + /// ditto + pragma(inline, true) bool isChunkSaveEvent() const => _tag == Tag.chunkSaveEvent; + ///ditto + alias getChunkSaveEvent = _get!(Tag.chunkSaveEvent); + + /++ + + +/ + alias chunkSendEvent = _create!(Tag.chunkSendEvent); + /// ditto + pragma(inline, true) bool isChunkSendEvent() const => _tag == Tag.chunkSendEvent; + ///ditto + alias getChunkSendEvent = _get!(Tag.chunkSendEvent); + + /++ + + +/ + alias entityDamageEvent = _create!(Tag.entityDamageEvent); + /// ditto + pragma(inline, true) bool isEntityDamageEvent() const => _tag == Tag.entityDamageEvent; + ///ditto + alias getEntityDamageEvent = _get!(Tag.entityDamageEvent); + + /++ + + +/ + alias entityDeathEvent = _create!(Tag.entityDeathEvent); + /// ditto + pragma(inline, true) bool isEntityDeathEvent() const => _tag == Tag.entityDeathEvent; + ///ditto + alias getEntityDeathEvent = _get!(Tag.entityDeathEvent); + + /++ + + +/ + alias playerDeathEvent = _create!(Tag.playerDeathEvent); + /// ditto + pragma(inline, true) bool isPlayerDeathEvent() const => _tag == Tag.playerDeathEvent; + ///ditto + alias getPlayerDeathEvent = _get!(Tag.playerDeathEvent); + + /++ + + +/ + alias entitySpawnEvent = _create!(Tag.entitySpawnEvent); + /// ditto + pragma(inline, true) bool isEntitySpawnEvent() const => _tag == Tag.entitySpawnEvent; + ///ditto + alias getEntitySpawnEvent = _get!(Tag.entitySpawnEvent); + + /++ + + +/ + alias entityCombustEvent = _create!(Tag.entityCombustEvent); + /// ditto + pragma(inline, true) bool isEntityCombustEvent() const => _tag == Tag.entityCombustEvent; + ///ditto + alias getEntityCombustEvent = _get!(Tag.entityCombustEvent); + + /++ + + +/ + alias entityRegainHealthEvent = _create!(Tag.entityRegainHealthEvent); + /// ditto + pragma(inline, true) bool isEntityRegainHealthEvent() const => _tag == Tag.entityRegainHealthEvent; + ///ditto + alias getEntityRegainHealthEvent = _get!(Tag.entityRegainHealthEvent); + + /++ + + +/ + alias entityAirChangeEvent = _create!(Tag.entityAirChangeEvent); + /// ditto + pragma(inline, true) bool isEntityAirChangeEvent() const => _tag == Tag.entityAirChangeEvent; + ///ditto + alias getEntityAirChangeEvent = _get!(Tag.entityAirChangeEvent); + + /++ + + +/ + alias entityBreedEvent = _create!(Tag.entityBreedEvent); + /// ditto + pragma(inline, true) bool isEntityBreedEvent() const => _tag == Tag.entityBreedEvent; + ///ditto + alias getEntityBreedEvent = _get!(Tag.entityBreedEvent); + + /++ + + +/ + alias entityDismountEvent = _create!(Tag.entityDismountEvent); + /// ditto + pragma(inline, true) bool isEntityDismountEvent() const => _tag == Tag.entityDismountEvent; + ///ditto + alias getEntityDismountEvent = _get!(Tag.entityDismountEvent); + + /++ + + +/ + alias entityDyeEvent = _create!(Tag.entityDyeEvent); + /// ditto + pragma(inline, true) bool isEntityDyeEvent() const => _tag == Tag.entityDyeEvent; + ///ditto + alias getEntityDyeEvent = _get!(Tag.entityDyeEvent); + + /++ + + +/ + alias entityEnterLoveModeEvent = _create!(Tag.entityEnterLoveModeEvent); + /// ditto + pragma(inline, true) bool isEntityEnterLoveModeEvent() const => _tag == Tag.entityEnterLoveModeEvent; + ///ditto + alias getEntityEnterLoveModeEvent = _get!(Tag.entityEnterLoveModeEvent); + + /++ + + +/ + alias entityExplodeEvent = _create!(Tag.entityExplodeEvent); + /// ditto + pragma(inline, true) bool isEntityExplodeEvent() const => _tag == Tag.entityExplodeEvent; + ///ditto + alias getEntityExplodeEvent = _get!(Tag.entityExplodeEvent); + + /++ + + +/ + alias entityMountEvent = _create!(Tag.entityMountEvent); + /// ditto + pragma(inline, true) bool isEntityMountEvent() const => _tag == Tag.entityMountEvent; + ///ditto + alias getEntityMountEvent = _get!(Tag.entityMountEvent); + + /++ + + +/ + alias entityPickupItemEvent = _create!(Tag.entityPickupItemEvent); + /// ditto + pragma(inline, true) bool isEntityPickupItemEvent() const => _tag == Tag.entityPickupItemEvent; + ///ditto + alias getEntityPickupItemEvent = _get!(Tag.entityPickupItemEvent); + + /++ + + +/ + alias entityPortalEvent = _create!(Tag.entityPortalEvent); + /// ditto + pragma(inline, true) bool isEntityPortalEvent() const => _tag == Tag.entityPortalEvent; + ///ditto + alias getEntityPortalEvent = _get!(Tag.entityPortalEvent); + + /++ + + +/ + alias entityResurrectEvent = _create!(Tag.entityResurrectEvent); + /// ditto + pragma(inline, true) bool isEntityResurrectEvent() const => _tag == Tag.entityResurrectEvent; + ///ditto + alias getEntityResurrectEvent = _get!(Tag.entityResurrectEvent); + + /++ + + +/ + alias entityShootBowEvent = _create!(Tag.entityShootBowEvent); + /// ditto + pragma(inline, true) bool isEntityShootBowEvent() const => _tag == Tag.entityShootBowEvent; + ///ditto + alias getEntityShootBowEvent = _get!(Tag.entityShootBowEvent); + + /++ + + +/ + alias entityTameEvent = _create!(Tag.entityTameEvent); + /// ditto + pragma(inline, true) bool isEntityTameEvent() const => _tag == Tag.entityTameEvent; + ///ditto + alias getEntityTameEvent = _get!(Tag.entityTameEvent); + + /++ + + +/ + alias entityTargetEvent = _create!(Tag.entityTargetEvent); + /// ditto + pragma(inline, true) bool isEntityTargetEvent() const => _tag == Tag.entityTargetEvent; + ///ditto + alias getEntityTargetEvent = _get!(Tag.entityTargetEvent); + + /++ + + +/ + alias entityTeleportEvent = _create!(Tag.entityTeleportEvent); + /// ditto + pragma(inline, true) bool isEntityTeleportEvent() const => _tag == Tag.entityTeleportEvent; + ///ditto + alias getEntityTeleportEvent = _get!(Tag.entityTeleportEvent); + + /++ + + +/ + alias entityToggleGlideEvent = _create!(Tag.entityToggleGlideEvent); + /// ditto + pragma(inline, true) bool isEntityToggleGlideEvent() const => _tag == Tag.entityToggleGlideEvent; + ///ditto + alias getEntityToggleGlideEvent = _get!(Tag.entityToggleGlideEvent); + + /++ + + +/ + alias entityTransformEvent = _create!(Tag.entityTransformEvent); + /// ditto + pragma(inline, true) bool isEntityTransformEvent() const => _tag == Tag.entityTransformEvent; + ///ditto + alias getEntityTransformEvent = _get!(Tag.entityTransformEvent); + + /++ + + +/ + alias playerItemConsumeEvent = _create!(Tag.playerItemConsumeEvent); + /// ditto + pragma(inline, true) bool isPlayerItemConsumeEvent() const => _tag == Tag.playerItemConsumeEvent; + ///ditto + alias getPlayerItemConsumeEvent = _get!(Tag.playerItemConsumeEvent); + + /++ + + +/ + alias playerItemDamageEvent = _create!(Tag.playerItemDamageEvent); + /// ditto + pragma(inline, true) bool isPlayerItemDamageEvent() const => _tag == Tag.playerItemDamageEvent; + ///ditto + alias getPlayerItemDamageEvent = _get!(Tag.playerItemDamageEvent); + + /++ + + +/ + alias playerDropItemEvent = _create!(Tag.playerDropItemEvent); + /// ditto + pragma(inline, true) bool isPlayerDropItemEvent() const => _tag == Tag.playerDropItemEvent; + ///ditto + alias getPlayerDropItemEvent = _get!(Tag.playerDropItemEvent); + + /++ + + +/ + alias playerBedEnterEvent = _create!(Tag.playerBedEnterEvent); + /// ditto + pragma(inline, true) bool isPlayerBedEnterEvent() const => _tag == Tag.playerBedEnterEvent; + ///ditto + alias getPlayerBedEnterEvent = _get!(Tag.playerBedEnterEvent); + + /++ + + +/ + alias playerBedLeaveEvent = _create!(Tag.playerBedLeaveEvent); + /// ditto + pragma(inline, true) bool isPlayerBedLeaveEvent() const => _tag == Tag.playerBedLeaveEvent; + ///ditto + alias getPlayerBedLeaveEvent = _get!(Tag.playerBedLeaveEvent); + + /++ + + +/ + alias playerBucketEmptyEvent = _create!(Tag.playerBucketEmptyEvent); + /// ditto + pragma(inline, true) bool isPlayerBucketEmptyEvent() const => _tag == Tag.playerBucketEmptyEvent; + ///ditto + alias getPlayerBucketEmptyEvent = _get!(Tag.playerBucketEmptyEvent); + + /++ + + +/ + alias playerBucketFillEvent = _create!(Tag.playerBucketFillEvent); + /// ditto + pragma(inline, true) bool isPlayerBucketFillEvent() const => _tag == Tag.playerBucketFillEvent; + ///ditto + alias getPlayerBucketFillEvent = _get!(Tag.playerBucketFillEvent); + + /++ + + +/ + alias blockDamageEvent = _create!(Tag.blockDamageEvent); + /// ditto + pragma(inline, true) bool isBlockDamageEvent() const => _tag == Tag.blockDamageEvent; + ///ditto + alias getBlockDamageEvent = _get!(Tag.blockDamageEvent); + + /++ + + +/ + alias blockIgniteEvent = _create!(Tag.blockIgniteEvent); + /// ditto + pragma(inline, true) bool isBlockIgniteEvent() const => _tag == Tag.blockIgniteEvent; + ///ditto + alias getBlockIgniteEvent = _get!(Tag.blockIgniteEvent); + + /++ + + +/ + alias blockFromToEvent = _create!(Tag.blockFromToEvent); + /// ditto + pragma(inline, true) bool isBlockFromToEvent() const => _tag == Tag.blockFromToEvent; + ///ditto + alias getBlockFromToEvent = _get!(Tag.blockFromToEvent); + + /++ + + +/ + alias blockFormEvent = _create!(Tag.blockFormEvent); + /// ditto + pragma(inline, true) bool isBlockFormEvent() const => _tag == Tag.blockFormEvent; + ///ditto + alias getBlockFormEvent = _get!(Tag.blockFormEvent); + + /++ + + +/ + alias blockFadeEvent = _create!(Tag.blockFadeEvent); + /// ditto + pragma(inline, true) bool isBlockFadeEvent() const => _tag == Tag.blockFadeEvent; + ///ditto + alias getBlockFadeEvent = _get!(Tag.blockFadeEvent); + + /++ + + +/ + alias blockDispenseEvent = _create!(Tag.blockDispenseEvent); + /// ditto + pragma(inline, true) bool isBlockDispenseEvent() const => _tag == Tag.blockDispenseEvent; + ///ditto + alias getBlockDispenseEvent = _get!(Tag.blockDispenseEvent); + + /++ + + +/ + alias blockExplodeEvent = _create!(Tag.blockExplodeEvent); + /// ditto + pragma(inline, true) bool isBlockExplodeEvent() const => _tag == Tag.blockExplodeEvent; + ///ditto + alias getBlockExplodeEvent = _get!(Tag.blockExplodeEvent); + + /++ + + +/ + alias blockPhysicsEvent = _create!(Tag.blockPhysicsEvent); + /// ditto + pragma(inline, true) bool isBlockPhysicsEvent() const => _tag == Tag.blockPhysicsEvent; + ///ditto + alias getBlockPhysicsEvent = _get!(Tag.blockPhysicsEvent); + + /++ + + +/ + alias blockPistonExtendEvent = _create!(Tag.blockPistonExtendEvent); + /// ditto + pragma(inline, true) bool isBlockPistonExtendEvent() const => _tag == Tag.blockPistonExtendEvent; + ///ditto + alias getBlockPistonExtendEvent = _get!(Tag.blockPistonExtendEvent); + + /++ + + +/ + alias blockPistonRetractEvent = _create!(Tag.blockPistonRetractEvent); + /// ditto + pragma(inline, true) bool isBlockPistonRetractEvent() const => _tag == Tag.blockPistonRetractEvent; + ///ditto + alias getBlockPistonRetractEvent = _get!(Tag.blockPistonRetractEvent); + + /++ + + +/ + alias notePlayEvent = _create!(Tag.notePlayEvent); + /// ditto + pragma(inline, true) bool isNotePlayEvent() const => _tag == Tag.notePlayEvent; + ///ditto + alias getNotePlayEvent = _get!(Tag.notePlayEvent); + + /++ + + +/ + alias signChangeEvent = _create!(Tag.signChangeEvent); + /// ditto + pragma(inline, true) bool isSignChangeEvent() const => _tag == Tag.signChangeEvent; + ///ditto + alias getSignChangeEvent = _get!(Tag.signChangeEvent); + + /++ + + +/ + alias spongeAbsorbEvent = _create!(Tag.spongeAbsorbEvent); + /// ditto + pragma(inline, true) bool isSpongeAbsorbEvent() const => _tag == Tag.spongeAbsorbEvent; + ///ditto + alias getSpongeAbsorbEvent = _get!(Tag.spongeAbsorbEvent); + + /++ + + +/ + alias tntPrimeEvent = _create!(Tag.tntPrimeEvent); + /// ditto + pragma(inline, true) bool isTntPrimeEvent() const => _tag == Tag.tntPrimeEvent; + ///ditto + alias getTntPrimeEvent = _get!(Tag.tntPrimeEvent); + + /++ + + +/ + alias weatherChangeEvent = _create!(Tag.weatherChangeEvent); + /// ditto + pragma(inline, true) bool isWeatherChangeEvent() const => _tag == Tag.weatherChangeEvent; + ///ditto + alias getWeatherChangeEvent = _get!(Tag.weatherChangeEvent); + + /++ + + +/ + alias thunderChangeEvent = _create!(Tag.thunderChangeEvent); + /// ditto + pragma(inline, true) bool isThunderChangeEvent() const => _tag == Tag.thunderChangeEvent; + ///ditto + alias getThunderChangeEvent = _get!(Tag.thunderChangeEvent); + + /++ + + +/ + alias worldLoadEvent = _create!(Tag.worldLoadEvent); + /// ditto + pragma(inline, true) bool isWorldLoadEvent() const => _tag == Tag.worldLoadEvent; + ///ditto + alias getWorldLoadEvent = _get!(Tag.worldLoadEvent); + + /++ + + +/ + alias worldUnloadEvent = _create!(Tag.worldUnloadEvent); + /// ditto + pragma(inline, true) bool isWorldUnloadEvent() const => _tag == Tag.worldUnloadEvent; + ///ditto + alias getWorldUnloadEvent = _get!(Tag.worldUnloadEvent); + + /++ + + +/ + alias asyncStructureGenerateEvent = _create!(Tag.asyncStructureGenerateEvent); + /// ditto + pragma(inline, true) bool isAsyncStructureGenerateEvent() const => _tag == Tag.asyncStructureGenerateEvent; + ///ditto + alias getAsyncStructureGenerateEvent = _get!(Tag.asyncStructureGenerateEvent); + + /++ + + +/ + alias asyncStructureSpawnEvent = _create!(Tag.asyncStructureSpawnEvent); + /// ditto + pragma(inline, true) bool isAsyncStructureSpawnEvent() const => _tag == Tag.asyncStructureSpawnEvent; + ///ditto + alias getAsyncStructureSpawnEvent = _get!(Tag.asyncStructureSpawnEvent); + + /++ + + +/ + alias chunkPopulateEvent = _create!(Tag.chunkPopulateEvent); + /// ditto + pragma(inline, true) bool isChunkPopulateEvent() const => _tag == Tag.chunkPopulateEvent; + ///ditto + alias getChunkPopulateEvent = _get!(Tag.chunkPopulateEvent); + + /++ + + +/ + alias chunkUnloadEvent = _create!(Tag.chunkUnloadEvent); + /// ditto + pragma(inline, true) bool isChunkUnloadEvent() const => _tag == Tag.chunkUnloadEvent; + ///ditto + alias getChunkUnloadEvent = _get!(Tag.chunkUnloadEvent); + + /++ + + +/ + alias entitiesLoadEvent = _create!(Tag.entitiesLoadEvent); + /// ditto + pragma(inline, true) bool isEntitiesLoadEvent() const => _tag == Tag.entitiesLoadEvent; + ///ditto + alias getEntitiesLoadEvent = _get!(Tag.entitiesLoadEvent); + + /++ + + +/ + alias entitiesUnloadEvent = _create!(Tag.entitiesUnloadEvent); + /// ditto + pragma(inline, true) bool isEntitiesUnloadEvent() const => _tag == Tag.entitiesUnloadEvent; + ///ditto + alias getEntitiesUnloadEvent = _get!(Tag.entitiesUnloadEvent); + + /++ + + +/ + alias genericGameEvent = _create!(Tag.genericGameEvent); + /// ditto + pragma(inline, true) bool isGenericGameEvent() const => _tag == Tag.genericGameEvent; + ///ditto + alias getGenericGameEvent = _get!(Tag.genericGameEvent); + + /++ + + +/ + alias lootGenerateEvent = _create!(Tag.lootGenerateEvent); + /// ditto + pragma(inline, true) bool isLootGenerateEvent() const => _tag == Tag.lootGenerateEvent; + ///ditto + alias getLootGenerateEvent = _get!(Tag.lootGenerateEvent); + + /++ + + +/ + alias portalCreateEvent = _create!(Tag.portalCreateEvent); + /// ditto + pragma(inline, true) bool isPortalCreateEvent() const => _tag == Tag.portalCreateEvent; + ///ditto + alias getPortalCreateEvent = _get!(Tag.portalCreateEvent); + + /++ + + +/ + alias structureGrowEvent = _create!(Tag.structureGrowEvent); + /// ditto + pragma(inline, true) bool isStructureGrowEvent() const => _tag == Tag.structureGrowEvent; + ///ditto + alias getStructureGrowEvent = _get!(Tag.structureGrowEvent); + + /++ + + +/ + alias timeSkipEvent = _create!(Tag.timeSkipEvent); + /// ditto + pragma(inline, true) bool isTimeSkipEvent() const => _tag == Tag.timeSkipEvent; + ///ditto + alias getTimeSkipEvent = _get!(Tag.timeSkipEvent); + + /++ + + +/ + alias worldInitEvent = _create!(Tag.worldInitEvent); + /// ditto + pragma(inline, true) bool isWorldInitEvent() const => _tag == Tag.worldInitEvent; + ///ditto + alias getWorldInitEvent = _get!(Tag.worldInitEvent); + + /++ + + +/ + alias worldSaveEvent = _create!(Tag.worldSaveEvent); + /// ditto + pragma(inline, true) bool isWorldSaveEvent() const => _tag == Tag.worldSaveEvent; + ///ditto + alias getWorldSaveEvent = _get!(Tag.worldSaveEvent); + + /++ + + +/ + alias inventoryOpenEvent = _create!(Tag.inventoryOpenEvent); + /// ditto + pragma(inline, true) bool isInventoryOpenEvent() const => _tag == Tag.inventoryOpenEvent; + ///ditto + alias getInventoryOpenEvent = _get!(Tag.inventoryOpenEvent); + + /++ + + +/ + alias inventoryDragEvent = _create!(Tag.inventoryDragEvent); + /// ditto + pragma(inline, true) bool isInventoryDragEvent() const => _tag == Tag.inventoryDragEvent; + ///ditto + alias getInventoryDragEvent = _get!(Tag.inventoryDragEvent); + + /++ + + +/ + alias craftItemEvent = _create!(Tag.craftItemEvent); + /// ditto + pragma(inline, true) bool isCraftItemEvent() const => _tag == Tag.craftItemEvent; + ///ditto + alias getCraftItemEvent = _get!(Tag.craftItemEvent); + + /++ + + +/ + alias furnaceSmeltEvent = _create!(Tag.furnaceSmeltEvent); + /// ditto + pragma(inline, true) bool isFurnaceSmeltEvent() const => _tag == Tag.furnaceSmeltEvent; + ///ditto + alias getFurnaceSmeltEvent = _get!(Tag.furnaceSmeltEvent); + + /++ + + +/ + alias brewEvent = _create!(Tag.brewEvent); + /// ditto + pragma(inline, true) bool isBrewEvent() const => _tag == Tag.brewEvent; + ///ditto + alias getBrewEvent = _get!(Tag.brewEvent); + + /++ + + +/ + alias brewingStandFuelEvent = _create!(Tag.brewingStandFuelEvent); + /// ditto + pragma(inline, true) bool isBrewingStandFuelEvent() const => _tag == Tag.brewingStandFuelEvent; + ///ditto + alias getBrewingStandFuelEvent = _get!(Tag.brewingStandFuelEvent); + + /++ + + +/ + alias furnaceBurnEvent = _create!(Tag.furnaceBurnEvent); + /// ditto + pragma(inline, true) bool isFurnaceBurnEvent() const => _tag == Tag.furnaceBurnEvent; + ///ditto + alias getFurnaceBurnEvent = _get!(Tag.furnaceBurnEvent); + + /++ + + +/ + alias furnaceExtractEvent = _create!(Tag.furnaceExtractEvent); + /// ditto + pragma(inline, true) bool isFurnaceExtractEvent() const => _tag == Tag.furnaceExtractEvent; + ///ditto + alias getFurnaceExtractEvent = _get!(Tag.furnaceExtractEvent); + + /++ + + +/ + alias furnaceStartSmeltEvent = _create!(Tag.furnaceStartSmeltEvent); + /// ditto + pragma(inline, true) bool isFurnaceStartSmeltEvent() const => _tag == Tag.furnaceStartSmeltEvent; + ///ditto + alias getFurnaceStartSmeltEvent = _get!(Tag.furnaceStartSmeltEvent); + + /++ + + +/ + alias hopperInventorySearchEvent = _create!(Tag.hopperInventorySearchEvent); + /// ditto + pragma(inline, true) bool isHopperInventorySearchEvent() const => _tag == Tag.hopperInventorySearchEvent; + ///ditto + alias getHopperInventorySearchEvent = _get!(Tag.hopperInventorySearchEvent); + + /++ + + +/ + alias inventoryCreativeEvent = _create!(Tag.inventoryCreativeEvent); + /// ditto + pragma(inline, true) bool isInventoryCreativeEvent() const => _tag == Tag.inventoryCreativeEvent; + ///ditto + alias getInventoryCreativeEvent = _get!(Tag.inventoryCreativeEvent); + + /++ + + +/ + alias inventoryInteractEvent = _create!(Tag.inventoryInteractEvent); + /// ditto + pragma(inline, true) bool isInventoryInteractEvent() const => _tag == Tag.inventoryInteractEvent; + ///ditto + alias getInventoryInteractEvent = _get!(Tag.inventoryInteractEvent); + + /++ + + +/ + alias inventoryMoveItemEvent = _create!(Tag.inventoryMoveItemEvent); + /// ditto + pragma(inline, true) bool isInventoryMoveItemEvent() const => _tag == Tag.inventoryMoveItemEvent; + ///ditto + alias getInventoryMoveItemEvent = _get!(Tag.inventoryMoveItemEvent); + + /++ + + +/ + alias inventoryPickupItemEvent = _create!(Tag.inventoryPickupItemEvent); + /// ditto + pragma(inline, true) bool isInventoryPickupItemEvent() const => _tag == Tag.inventoryPickupItemEvent; + ///ditto + alias getInventoryPickupItemEvent = _get!(Tag.inventoryPickupItemEvent); + + /++ + + +/ + alias prepareAnvilEvent = _create!(Tag.prepareAnvilEvent); + /// ditto + pragma(inline, true) bool isPrepareAnvilEvent() const => _tag == Tag.prepareAnvilEvent; + ///ditto + alias getPrepareAnvilEvent = _get!(Tag.prepareAnvilEvent); + + /++ + + +/ + alias prepareGrindstoneEvent = _create!(Tag.prepareGrindstoneEvent); + /// ditto + pragma(inline, true) bool isPrepareGrindstoneEvent() const => _tag == Tag.prepareGrindstoneEvent; + ///ditto + alias getPrepareGrindstoneEvent = _get!(Tag.prepareGrindstoneEvent); + + /++ + + +/ + alias prepareInventoryResultEvent = _create!(Tag.prepareInventoryResultEvent); + /// ditto + pragma(inline, true) bool isPrepareInventoryResultEvent() const => _tag == Tag.prepareInventoryResultEvent; + ///ditto + alias getPrepareInventoryResultEvent = _get!(Tag.prepareInventoryResultEvent); + + /++ + + +/ + alias prepareItemCraftEvent = _create!(Tag.prepareItemCraftEvent); + /// ditto + pragma(inline, true) bool isPrepareItemCraftEvent() const => _tag == Tag.prepareItemCraftEvent; + ///ditto + alias getPrepareItemCraftEvent = _get!(Tag.prepareItemCraftEvent); + + /++ + + +/ + alias prepareSmithingEvent = _create!(Tag.prepareSmithingEvent); + /// ditto + pragma(inline, true) bool isPrepareSmithingEvent() const => _tag == Tag.prepareSmithingEvent; + ///ditto + alias getPrepareSmithingEvent = _get!(Tag.prepareSmithingEvent); + + /++ + + +/ + alias smithItemEvent = _create!(Tag.smithItemEvent); + /// ditto + pragma(inline, true) bool isSmithItemEvent() const => _tag == Tag.smithItemEvent; + ///ditto + alias getSmithItemEvent = _get!(Tag.smithItemEvent); + + /++ + + +/ + alias tradeSelectEvent = _create!(Tag.tradeSelectEvent); + /// ditto + pragma(inline, true) bool isTradeSelectEvent() const => _tag == Tag.tradeSelectEvent; + ///ditto + alias getTradeSelectEvent = _get!(Tag.tradeSelectEvent); + + /++ + + +/ + alias vehicleBlockCollisionEvent = _create!(Tag.vehicleBlockCollisionEvent); + /// ditto + pragma(inline, true) bool isVehicleBlockCollisionEvent() const => _tag == Tag.vehicleBlockCollisionEvent; + ///ditto + alias getVehicleBlockCollisionEvent = _get!(Tag.vehicleBlockCollisionEvent); + + /++ + + +/ + alias vehicleCollisionEvent = _create!(Tag.vehicleCollisionEvent); + /// ditto + pragma(inline, true) bool isVehicleCollisionEvent() const => _tag == Tag.vehicleCollisionEvent; + ///ditto + alias getVehicleCollisionEvent = _get!(Tag.vehicleCollisionEvent); + + /++ + + +/ + alias vehicleCreateEvent = _create!(Tag.vehicleCreateEvent); + /// ditto + pragma(inline, true) bool isVehicleCreateEvent() const => _tag == Tag.vehicleCreateEvent; + ///ditto + alias getVehicleCreateEvent = _get!(Tag.vehicleCreateEvent); + + /++ + + +/ + alias vehicleDamageEvent = _create!(Tag.vehicleDamageEvent); + /// ditto + pragma(inline, true) bool isVehicleDamageEvent() const => _tag == Tag.vehicleDamageEvent; + ///ditto + alias getVehicleDamageEvent = _get!(Tag.vehicleDamageEvent); + + /++ + + +/ + alias vehicleDestroyEvent = _create!(Tag.vehicleDestroyEvent); + /// ditto + pragma(inline, true) bool isVehicleDestroyEvent() const => _tag == Tag.vehicleDestroyEvent; + ///ditto + alias getVehicleDestroyEvent = _get!(Tag.vehicleDestroyEvent); + + /++ + + +/ + alias vehicleEnterEvent = _create!(Tag.vehicleEnterEvent); + /// ditto + pragma(inline, true) bool isVehicleEnterEvent() const => _tag == Tag.vehicleEnterEvent; + ///ditto + alias getVehicleEnterEvent = _get!(Tag.vehicleEnterEvent); + + /++ + + +/ + alias vehicleEntityCollisionEvent = _create!(Tag.vehicleEntityCollisionEvent); + /// ditto + pragma(inline, true) bool isVehicleEntityCollisionEvent() const => _tag == Tag.vehicleEntityCollisionEvent; + ///ditto + alias getVehicleEntityCollisionEvent = _get!(Tag.vehicleEntityCollisionEvent); + + /++ + + +/ + alias vehicleExitEvent = _create!(Tag.vehicleExitEvent); + /// ditto + pragma(inline, true) bool isVehicleExitEvent() const => _tag == Tag.vehicleExitEvent; + ///ditto + alias getVehicleExitEvent = _get!(Tag.vehicleExitEvent); + + /++ + + +/ + alias vehicleMoveEvent = _create!(Tag.vehicleMoveEvent); + /// ditto + pragma(inline, true) bool isVehicleMoveEvent() const => _tag == Tag.vehicleMoveEvent; + ///ditto + alias getVehicleMoveEvent = _get!(Tag.vehicleMoveEvent); + + /++ + + +/ + alias vehicleUpdateEvent = _create!(Tag.vehicleUpdateEvent); + /// ditto + pragma(inline, true) bool isVehicleUpdateEvent() const => _tag == Tag.vehicleUpdateEvent; + ///ditto + alias getVehicleUpdateEvent = _get!(Tag.vehicleUpdateEvent); + + /++ + + +/ + alias prepareItemEnchantEvent = _create!(Tag.prepareItemEnchantEvent); + /// ditto + pragma(inline, true) bool isPrepareItemEnchantEvent() const => _tag == Tag.prepareItemEnchantEvent; + ///ditto + alias getPrepareItemEnchantEvent = _get!(Tag.prepareItemEnchantEvent); + + /++ + + +/ + alias enchantItemEvent = _create!(Tag.enchantItemEvent); + /// ditto + pragma(inline, true) bool isEnchantItemEvent() const => _tag == Tag.enchantItemEvent; + ///ditto + alias getEnchantItemEvent = _get!(Tag.enchantItemEvent); + + /++ + + +/ + alias mapInitializeEvent = _create!(Tag.mapInitializeEvent); + /// ditto + pragma(inline, true) bool isMapInitializeEvent() const => _tag == Tag.mapInitializeEvent; + ///ditto + alias getMapInitializeEvent = _get!(Tag.mapInitializeEvent); + + /++ + + +/ + alias hangingBreakEvent = _create!(Tag.hangingBreakEvent); + /// ditto + pragma(inline, true) bool isHangingBreakEvent() const => _tag == Tag.hangingBreakEvent; + ///ditto + alias getHangingBreakEvent = _get!(Tag.hangingBreakEvent); + + /++ + + +/ + alias hangingBreakByEntityEvent = _create!(Tag.hangingBreakByEntityEvent); + /// ditto + pragma(inline, true) bool isHangingBreakByEntityEvent() const => _tag == Tag.hangingBreakByEntityEvent; + ///ditto + alias getHangingBreakByEntityEvent = _get!(Tag.hangingBreakByEntityEvent); + + /++ + + +/ + alias hangingPlaceEvent = _create!(Tag.hangingPlaceEvent); + /// ditto + pragma(inline, true) bool isHangingPlaceEvent() const => _tag == Tag.hangingPlaceEvent; + ///ditto + alias getHangingPlaceEvent = _get!(Tag.hangingPlaceEvent); + + /++ + + +/ + alias bellResonateEvent = _create!(Tag.bellResonateEvent); + /// ditto + pragma(inline, true) bool isBellResonateEvent() const => _tag == Tag.bellResonateEvent; + ///ditto + alias getBellResonateEvent = _get!(Tag.bellResonateEvent); + + /++ + + +/ + alias bellRingEvent = _create!(Tag.bellRingEvent); + /// ditto + pragma(inline, true) bool isBellRingEvent() const => _tag == Tag.bellRingEvent; + ///ditto + alias getBellRingEvent = _get!(Tag.bellRingEvent); + + /++ + + +/ + alias blockBrushEvent = _create!(Tag.blockBrushEvent); + /// ditto + pragma(inline, true) bool isBlockBrushEvent() const => _tag == Tag.blockBrushEvent; + ///ditto + alias getBlockBrushEvent = _get!(Tag.blockBrushEvent); + + /++ + + +/ + alias blockCookEvent = _create!(Tag.blockCookEvent); + /// ditto + pragma(inline, true) bool isBlockCookEvent() const => _tag == Tag.blockCookEvent; + ///ditto + alias getBlockCookEvent = _get!(Tag.blockCookEvent); + + /++ + + +/ + alias blockDamageAbortEvent = _create!(Tag.blockDamageAbortEvent); + /// ditto + pragma(inline, true) bool isBlockDamageAbortEvent() const => _tag == Tag.blockDamageAbortEvent; + ///ditto + alias getBlockDamageAbortEvent = _get!(Tag.blockDamageAbortEvent); + + /++ + + +/ + alias blockDispenseArmorEvent = _create!(Tag.blockDispenseArmorEvent); + /// ditto + pragma(inline, true) bool isBlockDispenseArmorEvent() const => _tag == Tag.blockDispenseArmorEvent; + ///ditto + alias getBlockDispenseArmorEvent = _get!(Tag.blockDispenseArmorEvent); + + /++ + + +/ + alias blockDispenseLootEvent = _create!(Tag.blockDispenseLootEvent); + /// ditto + pragma(inline, true) bool isBlockDispenseLootEvent() const => _tag == Tag.blockDispenseLootEvent; + ///ditto + alias getBlockDispenseLootEvent = _get!(Tag.blockDispenseLootEvent); + + /++ + + +/ + alias blockDropItemEvent = _create!(Tag.blockDropItemEvent); + /// ditto + pragma(inline, true) bool isBlockDropItemEvent() const => _tag == Tag.blockDropItemEvent; + ///ditto + alias getBlockDropItemEvent = _get!(Tag.blockDropItemEvent); + + /++ + + +/ + alias blockExpEvent = _create!(Tag.blockExpEvent); + /// ditto + pragma(inline, true) bool isBlockExpEvent() const => _tag == Tag.blockExpEvent; + ///ditto + alias getBlockExpEvent = _get!(Tag.blockExpEvent); + + /++ + + +/ + alias blockFertilizeEvent = _create!(Tag.blockFertilizeEvent); + /// ditto + pragma(inline, true) bool isBlockFertilizeEvent() const => _tag == Tag.blockFertilizeEvent; + ///ditto + alias getBlockFertilizeEvent = _get!(Tag.blockFertilizeEvent); + + /++ + + +/ + alias blockMultiPlaceEvent = _create!(Tag.blockMultiPlaceEvent); + /// ditto + pragma(inline, true) bool isBlockMultiPlaceEvent() const => _tag == Tag.blockMultiPlaceEvent; + ///ditto + alias getBlockMultiPlaceEvent = _get!(Tag.blockMultiPlaceEvent); + + /++ + + +/ + alias blockReceiveGameEvent = _create!(Tag.blockReceiveGameEvent); + /// ditto + pragma(inline, true) bool isBlockReceiveGameEvent() const => _tag == Tag.blockReceiveGameEvent; + ///ditto + alias getBlockReceiveGameEvent = _get!(Tag.blockReceiveGameEvent); + + /++ + + +/ + alias blockShearEntityEvent = _create!(Tag.blockShearEntityEvent); + /// ditto + pragma(inline, true) bool isBlockShearEntityEvent() const => _tag == Tag.blockShearEntityEvent; + ///ditto + alias getBlockShearEntityEvent = _get!(Tag.blockShearEntityEvent); + + /++ + + +/ + alias blockSpreadEvent = _create!(Tag.blockSpreadEvent); + /// ditto + pragma(inline, true) bool isBlockSpreadEvent() const => _tag == Tag.blockSpreadEvent; + ///ditto + alias getBlockSpreadEvent = _get!(Tag.blockSpreadEvent); + + /++ + + +/ + alias brewingStartEvent = _create!(Tag.brewingStartEvent); + /// ditto + pragma(inline, true) bool isBrewingStartEvent() const => _tag == Tag.brewingStartEvent; + ///ditto + alias getBrewingStartEvent = _get!(Tag.brewingStartEvent); + + /++ + + +/ + alias campfireStartEvent = _create!(Tag.campfireStartEvent); + /// ditto + pragma(inline, true) bool isCampfireStartEvent() const => _tag == Tag.campfireStartEvent; + ///ditto + alias getCampfireStartEvent = _get!(Tag.campfireStartEvent); + + /++ + + +/ + alias cauldronLevelChangeEvent = _create!(Tag.cauldronLevelChangeEvent); + /// ditto + pragma(inline, true) bool isCauldronLevelChangeEvent() const => _tag == Tag.cauldronLevelChangeEvent; + ///ditto + alias getCauldronLevelChangeEvent = _get!(Tag.cauldronLevelChangeEvent); + + /++ + + +/ + alias crafterCraftEvent = _create!(Tag.crafterCraftEvent); + /// ditto + pragma(inline, true) bool isCrafterCraftEvent() const => _tag == Tag.crafterCraftEvent; + ///ditto + alias getCrafterCraftEvent = _get!(Tag.crafterCraftEvent); + + /++ + + +/ + alias entityBlockFormEvent = _create!(Tag.entityBlockFormEvent); + /// ditto + pragma(inline, true) bool isEntityBlockFormEvent() const => _tag == Tag.entityBlockFormEvent; + ///ditto + alias getEntityBlockFormEvent = _get!(Tag.entityBlockFormEvent); + + /++ + + +/ + alias fluidLevelChangeEvent = _create!(Tag.fluidLevelChangeEvent); + /// ditto + pragma(inline, true) bool isFluidLevelChangeEvent() const => _tag == Tag.fluidLevelChangeEvent; + ///ditto + alias getFluidLevelChangeEvent = _get!(Tag.fluidLevelChangeEvent); + + /++ + + +/ + alias inventoryBlockStartEvent = _create!(Tag.inventoryBlockStartEvent); + /// ditto + pragma(inline, true) bool isInventoryBlockStartEvent() const => _tag == Tag.inventoryBlockStartEvent; + ///ditto + alias getInventoryBlockStartEvent = _get!(Tag.inventoryBlockStartEvent); + + /++ + + +/ + alias leavesDecayEvent = _create!(Tag.leavesDecayEvent); + /// ditto + pragma(inline, true) bool isLeavesDecayEvent() const => _tag == Tag.leavesDecayEvent; + ///ditto + alias getLeavesDecayEvent = _get!(Tag.leavesDecayEvent); + + /++ + + +/ + alias moistureChangeEvent = _create!(Tag.moistureChangeEvent); + /// ditto + pragma(inline, true) bool isMoistureChangeEvent() const => _tag == Tag.moistureChangeEvent; + ///ditto + alias getMoistureChangeEvent = _get!(Tag.moistureChangeEvent); + + /++ + + +/ + alias sculkBloomEvent = _create!(Tag.sculkBloomEvent); + /// ditto + pragma(inline, true) bool isSculkBloomEvent() const => _tag == Tag.sculkBloomEvent; + ///ditto + alias getSculkBloomEvent = _get!(Tag.sculkBloomEvent); + + /++ + + +/ + alias vaultDisplayItemEvent = _create!(Tag.vaultDisplayItemEvent); + /// ditto + pragma(inline, true) bool isVaultDisplayItemEvent() const => _tag == Tag.vaultDisplayItemEvent; + ///ditto + alias getVaultDisplayItemEvent = _get!(Tag.vaultDisplayItemEvent); + + /++ + + +/ + alias creatureSpawnEvent = _create!(Tag.creatureSpawnEvent); + /// ditto + pragma(inline, true) bool isCreatureSpawnEvent() const => _tag == Tag.creatureSpawnEvent; + ///ditto + alias getCreatureSpawnEvent = _get!(Tag.creatureSpawnEvent); + + /++ + + +/ + alias enderDragonChangePhaseEvent = _create!(Tag.enderDragonChangePhaseEvent); + /// ditto + pragma(inline, true) bool isEnderDragonChangePhaseEvent() const => _tag == Tag.enderDragonChangePhaseEvent; + ///ditto + alias getEnderDragonChangePhaseEvent = _get!(Tag.enderDragonChangePhaseEvent); + + /++ + + +/ + alias entityBreakDoorEvent = _create!(Tag.entityBreakDoorEvent); + /// ditto + pragma(inline, true) bool isEntityBreakDoorEvent() const => _tag == Tag.entityBreakDoorEvent; + ///ditto + alias getEntityBreakDoorEvent = _get!(Tag.entityBreakDoorEvent); + + /++ + + +/ + alias entityChangeBlockEvent = _create!(Tag.entityChangeBlockEvent); + /// ditto + pragma(inline, true) bool isEntityChangeBlockEvent() const => _tag == Tag.entityChangeBlockEvent; + ///ditto + alias getEntityChangeBlockEvent = _get!(Tag.entityChangeBlockEvent); + + /++ + + +/ + alias entityDamageByBlockEvent = _create!(Tag.entityDamageByBlockEvent); + /// ditto + pragma(inline, true) bool isEntityDamageByBlockEvent() const => _tag == Tag.entityDamageByBlockEvent; + ///ditto + alias getEntityDamageByBlockEvent = _get!(Tag.entityDamageByBlockEvent); + + /++ + + +/ + alias entityDamageByEntityEvent = _create!(Tag.entityDamageByEntityEvent); + /// ditto + pragma(inline, true) bool isEntityDamageByEntityEvent() const => _tag == Tag.entityDamageByEntityEvent; + ///ditto + alias getEntityDamageByEntityEvent = _get!(Tag.entityDamageByEntityEvent); + + /++ + + +/ + alias entityDropItemEvent = _create!(Tag.entityDropItemEvent); + /// ditto + pragma(inline, true) bool isEntityDropItemEvent() const => _tag == Tag.entityDropItemEvent; + ///ditto + alias getEntityDropItemEvent = _get!(Tag.entityDropItemEvent); + + /++ + + +/ + alias entityEnterBlockEvent = _create!(Tag.entityEnterBlockEvent); + /// ditto + pragma(inline, true) bool isEntityEnterBlockEvent() const => _tag == Tag.entityEnterBlockEvent; + ///ditto + alias getEntityEnterBlockEvent = _get!(Tag.entityEnterBlockEvent); + + /++ + + +/ + alias entityExhaustionEvent = _create!(Tag.entityExhaustionEvent); + /// ditto + pragma(inline, true) bool isEntityExhaustionEvent() const => _tag == Tag.entityExhaustionEvent; + ///ditto + alias getEntityExhaustionEvent = _get!(Tag.entityExhaustionEvent); + + /++ + + +/ + alias entityInteractEvent = _create!(Tag.entityInteractEvent); + /// ditto + pragma(inline, true) bool isEntityInteractEvent() const => _tag == Tag.entityInteractEvent; + ///ditto + alias getEntityInteractEvent = _get!(Tag.entityInteractEvent); + + /++ + + +/ + alias entityKnockbackEvent = _create!(Tag.entityKnockbackEvent); + /// ditto + pragma(inline, true) bool isEntityKnockbackEvent() const => _tag == Tag.entityKnockbackEvent; + ///ditto + alias getEntityKnockbackEvent = _get!(Tag.entityKnockbackEvent); + + /++ + + +/ + alias entityPlaceEvent = _create!(Tag.entityPlaceEvent); + /// ditto + pragma(inline, true) bool isEntityPlaceEvent() const => _tag == Tag.entityPlaceEvent; + ///ditto + alias getEntityPlaceEvent = _get!(Tag.entityPlaceEvent); + + /++ + + +/ + alias entityPoseChangeEvent = _create!(Tag.entityPoseChangeEvent); + /// ditto + pragma(inline, true) bool isEntityPoseChangeEvent() const => _tag == Tag.entityPoseChangeEvent; + ///ditto + alias getEntityPoseChangeEvent = _get!(Tag.entityPoseChangeEvent); + + /++ + + +/ + alias entityPotionEffectEvent = _create!(Tag.entityPotionEffectEvent); + /// ditto + pragma(inline, true) bool isEntityPotionEffectEvent() const => _tag == Tag.entityPotionEffectEvent; + ///ditto + alias getEntityPotionEffectEvent = _get!(Tag.entityPotionEffectEvent); + + /++ + + +/ + alias entitySpellCastEvent = _create!(Tag.entitySpellCastEvent); + /// ditto + pragma(inline, true) bool isEntitySpellCastEvent() const => _tag == Tag.entitySpellCastEvent; + ///ditto + alias getEntitySpellCastEvent = _get!(Tag.entitySpellCastEvent); + + /++ + + +/ + alias entityTargetLivingEntityEvent = _create!(Tag.entityTargetLivingEntityEvent); + /// ditto + pragma(inline, true) bool isEntityTargetLivingEntityEvent() const => _tag == Tag.entityTargetLivingEntityEvent; + ///ditto + alias getEntityTargetLivingEntityEvent = _get!(Tag.entityTargetLivingEntityEvent); + + /++ + + +/ + alias entityToggleSwimEvent = _create!(Tag.entityToggleSwimEvent); + /// ditto + pragma(inline, true) bool isEntityToggleSwimEvent() const => _tag == Tag.entityToggleSwimEvent; + ///ditto + alias getEntityToggleSwimEvent = _get!(Tag.entityToggleSwimEvent); + + /++ + + +/ + alias explosionPrimeEvent = _create!(Tag.explosionPrimeEvent); + /// ditto + pragma(inline, true) bool isExplosionPrimeEvent() const => _tag == Tag.explosionPrimeEvent; + ///ditto + alias getExplosionPrimeEvent = _get!(Tag.explosionPrimeEvent); + + /++ + + +/ + alias fireworkExplodeEvent = _create!(Tag.fireworkExplodeEvent); + /// ditto + pragma(inline, true) bool isFireworkExplodeEvent() const => _tag == Tag.fireworkExplodeEvent; + ///ditto + alias getFireworkExplodeEvent = _get!(Tag.fireworkExplodeEvent); + + /++ + + +/ + alias foodLevelChangeEvent = _create!(Tag.foodLevelChangeEvent); + /// ditto + pragma(inline, true) bool isFoodLevelChangeEvent() const => _tag == Tag.foodLevelChangeEvent; + ///ditto + alias getFoodLevelChangeEvent = _get!(Tag.foodLevelChangeEvent); + + /++ + + +/ + alias itemDespawnEvent = _create!(Tag.itemDespawnEvent); + /// ditto + pragma(inline, true) bool isItemDespawnEvent() const => _tag == Tag.itemDespawnEvent; + ///ditto + alias getItemDespawnEvent = _get!(Tag.itemDespawnEvent); + + /++ + + +/ + alias itemMergeEvent = _create!(Tag.itemMergeEvent); + /// ditto + pragma(inline, true) bool isItemMergeEvent() const => _tag == Tag.itemMergeEvent; + ///ditto + alias getItemMergeEvent = _get!(Tag.itemMergeEvent); + + /++ + + +/ + alias itemSpawnEvent = _create!(Tag.itemSpawnEvent); + /// ditto + pragma(inline, true) bool isItemSpawnEvent() const => _tag == Tag.itemSpawnEvent; + ///ditto + alias getItemSpawnEvent = _get!(Tag.itemSpawnEvent); + + /++ + + +/ + alias piglinBarterEvent = _create!(Tag.piglinBarterEvent); + /// ditto + pragma(inline, true) bool isPiglinBarterEvent() const => _tag == Tag.piglinBarterEvent; + ///ditto + alias getPiglinBarterEvent = _get!(Tag.piglinBarterEvent); + + /++ + + +/ + alias projectileHitEvent = _create!(Tag.projectileHitEvent); + /// ditto + pragma(inline, true) bool isProjectileHitEvent() const => _tag == Tag.projectileHitEvent; + ///ditto + alias getProjectileHitEvent = _get!(Tag.projectileHitEvent); + + /++ + + +/ + alias projectileLaunchEvent = _create!(Tag.projectileLaunchEvent); + /// ditto + pragma(inline, true) bool isProjectileLaunchEvent() const => _tag == Tag.projectileLaunchEvent; + ///ditto + alias getProjectileLaunchEvent = _get!(Tag.projectileLaunchEvent); + + /++ + + +/ + alias sheepDyeWoolEvent = _create!(Tag.sheepDyeWoolEvent); + /// ditto + pragma(inline, true) bool isSheepDyeWoolEvent() const => _tag == Tag.sheepDyeWoolEvent; + ///ditto + alias getSheepDyeWoolEvent = _get!(Tag.sheepDyeWoolEvent); + + /++ + + +/ + alias sheepRegrowWoolEvent = _create!(Tag.sheepRegrowWoolEvent); + /// ditto + pragma(inline, true) bool isSheepRegrowWoolEvent() const => _tag == Tag.sheepRegrowWoolEvent; + ///ditto + alias getSheepRegrowWoolEvent = _get!(Tag.sheepRegrowWoolEvent); + + /++ + + +/ + alias slimeSplitEvent = _create!(Tag.slimeSplitEvent); + /// ditto + pragma(inline, true) bool isSlimeSplitEvent() const => _tag == Tag.slimeSplitEvent; + ///ditto + alias getSlimeSplitEvent = _get!(Tag.slimeSplitEvent); + + /++ + + +/ + alias striderTemperatureChangeEvent = _create!(Tag.striderTemperatureChangeEvent); + /// ditto + pragma(inline, true) bool isStriderTemperatureChangeEvent() const => _tag == Tag.striderTemperatureChangeEvent; + ///ditto + alias getStriderTemperatureChangeEvent = _get!(Tag.striderTemperatureChangeEvent); + + /++ + + +/ + alias villagerAcquireTradeEvent = _create!(Tag.villagerAcquireTradeEvent); + /// ditto + pragma(inline, true) bool isVillagerAcquireTradeEvent() const => _tag == Tag.villagerAcquireTradeEvent; + ///ditto + alias getVillagerAcquireTradeEvent = _get!(Tag.villagerAcquireTradeEvent); + + /++ + + +/ + alias villagerCareerChangeEvent = _create!(Tag.villagerCareerChangeEvent); + /// ditto + pragma(inline, true) bool isVillagerCareerChangeEvent() const => _tag == Tag.villagerCareerChangeEvent; + ///ditto + alias getVillagerCareerChangeEvent = _get!(Tag.villagerCareerChangeEvent); + + /++ + + +/ + alias villagerReplenishTradeEvent = _create!(Tag.villagerReplenishTradeEvent); + /// ditto + pragma(inline, true) bool isVillagerReplenishTradeEvent() const => _tag == Tag.villagerReplenishTradeEvent; + ///ditto + alias getVillagerReplenishTradeEvent = _get!(Tag.villagerReplenishTradeEvent); + + /++ + + +/ + alias wardenAngerChangeEvent = _create!(Tag.wardenAngerChangeEvent); + /// ditto + pragma(inline, true) bool isWardenAngerChangeEvent() const => _tag == Tag.wardenAngerChangeEvent; + ///ditto + alias getWardenAngerChangeEvent = _get!(Tag.wardenAngerChangeEvent); + + /++ + + +/ + alias areaEffectCloudApplyEvent = _create!(Tag.areaEffectCloudApplyEvent); + /// ditto + pragma(inline, true) bool isAreaEffectCloudApplyEvent() const => _tag == Tag.areaEffectCloudApplyEvent; + ///ditto + alias getAreaEffectCloudApplyEvent = _get!(Tag.areaEffectCloudApplyEvent); + + /++ + + +/ + alias arrowBodyCountChangeEvent = _create!(Tag.arrowBodyCountChangeEvent); + /// ditto + pragma(inline, true) bool isArrowBodyCountChangeEvent() const => _tag == Tag.arrowBodyCountChangeEvent; + ///ditto + alias getArrowBodyCountChangeEvent = _get!(Tag.arrowBodyCountChangeEvent); + + /++ + + +/ + alias batToggleSleepEvent = _create!(Tag.batToggleSleepEvent); + /// ditto + pragma(inline, true) bool isBatToggleSleepEvent() const => _tag == Tag.batToggleSleepEvent; + ///ditto + alias getBatToggleSleepEvent = _get!(Tag.batToggleSleepEvent); + + /++ + + +/ + alias creeperPowerEvent = _create!(Tag.creeperPowerEvent); + /// ditto + pragma(inline, true) bool isCreeperPowerEvent() const => _tag == Tag.creeperPowerEvent; + ///ditto + alias getCreeperPowerEvent = _get!(Tag.creeperPowerEvent); + + /++ + + +/ + alias entityCombustByBlockEvent = _create!(Tag.entityCombustByBlockEvent); + /// ditto + pragma(inline, true) bool isEntityCombustByBlockEvent() const => _tag == Tag.entityCombustByBlockEvent; + ///ditto + alias getEntityCombustByBlockEvent = _get!(Tag.entityCombustByBlockEvent); + + /++ + + +/ + alias entityCombustByEntityEvent = _create!(Tag.entityCombustByEntityEvent); + /// ditto + pragma(inline, true) bool isEntityCombustByEntityEvent() const => _tag == Tag.entityCombustByEntityEvent; + ///ditto + alias getEntityCombustByEntityEvent = _get!(Tag.entityCombustByEntityEvent); + + /++ + + +/ + alias entityKnockbackByEntityEvent = _create!(Tag.entityKnockbackByEntityEvent); + /// ditto + pragma(inline, true) bool isEntityKnockbackByEntityEvent() const => _tag == Tag.entityKnockbackByEntityEvent; + ///ditto + alias getEntityKnockbackByEntityEvent = _get!(Tag.entityKnockbackByEntityEvent); + + /++ + + +/ + alias entityPortalEnterEvent = _create!(Tag.entityPortalEnterEvent); + /// ditto + pragma(inline, true) bool isEntityPortalEnterEvent() const => _tag == Tag.entityPortalEnterEvent; + ///ditto + alias getEntityPortalEnterEvent = _get!(Tag.entityPortalEnterEvent); + + /++ + + +/ + alias entityPortalExitEvent = _create!(Tag.entityPortalExitEvent); + /// ditto + pragma(inline, true) bool isEntityPortalExitEvent() const => _tag == Tag.entityPortalExitEvent; + ///ditto + alias getEntityPortalExitEvent = _get!(Tag.entityPortalExitEvent); + + /++ + + +/ + alias entityRemoveEvent = _create!(Tag.entityRemoveEvent); + /// ditto + pragma(inline, true) bool isEntityRemoveEvent() const => _tag == Tag.entityRemoveEvent; + ///ditto + alias getEntityRemoveEvent = _get!(Tag.entityRemoveEvent); + + /++ + + +/ + alias entityTargetBlockEvent = _create!(Tag.entityTargetBlockEvent); + /// ditto + pragma(inline, true) bool isEntityTargetBlockEvent() const => _tag == Tag.entityTargetBlockEvent; + ///ditto + alias getEntityTargetBlockEvent = _get!(Tag.entityTargetBlockEvent); + + /++ + + +/ + alias entityUnleashEvent = _create!(Tag.entityUnleashEvent); + /// ditto + pragma(inline, true) bool isEntityUnleashEvent() const => _tag == Tag.entityUnleashEvent; + ///ditto + alias getEntityUnleashEvent = _get!(Tag.entityUnleashEvent); + + /++ + + +/ + alias expBottleEvent = _create!(Tag.expBottleEvent); + /// ditto + pragma(inline, true) bool isExpBottleEvent() const => _tag == Tag.expBottleEvent; + ///ditto + alias getExpBottleEvent = _get!(Tag.expBottleEvent); + + /++ + + +/ + alias horseJumpEvent = _create!(Tag.horseJumpEvent); + /// ditto + pragma(inline, true) bool isHorseJumpEvent() const => _tag == Tag.horseJumpEvent; + ///ditto + alias getHorseJumpEvent = _get!(Tag.horseJumpEvent); + + /++ + + +/ + alias lingeringPotionSplashEvent = _create!(Tag.lingeringPotionSplashEvent); + /// ditto + pragma(inline, true) bool isLingeringPotionSplashEvent() const => _tag == Tag.lingeringPotionSplashEvent; + ///ditto + alias getLingeringPotionSplashEvent = _get!(Tag.lingeringPotionSplashEvent); + + /++ + + +/ + alias pigZapEvent = _create!(Tag.pigZapEvent); + /// ditto + pragma(inline, true) bool isPigZapEvent() const => _tag == Tag.pigZapEvent; + ///ditto + alias getPigZapEvent = _get!(Tag.pigZapEvent); + + /++ + + +/ + alias pigZombieAngerEvent = _create!(Tag.pigZombieAngerEvent); + /// ditto + pragma(inline, true) bool isPigZombieAngerEvent() const => _tag == Tag.pigZombieAngerEvent; + ///ditto + alias getPigZombieAngerEvent = _get!(Tag.pigZombieAngerEvent); + + /++ + + +/ + alias potionSplashEvent = _create!(Tag.potionSplashEvent); + /// ditto + pragma(inline, true) bool isPotionSplashEvent() const => _tag == Tag.potionSplashEvent; + ///ditto + alias getPotionSplashEvent = _get!(Tag.potionSplashEvent); + + /++ + + +/ + alias spawnerSpawnEvent = _create!(Tag.spawnerSpawnEvent); + /// ditto + pragma(inline, true) bool isSpawnerSpawnEvent() const => _tag == Tag.spawnerSpawnEvent; + ///ditto + alias getSpawnerSpawnEvent = _get!(Tag.spawnerSpawnEvent); + + /++ + + +/ + alias trialSpawnerSpawnEvent = _create!(Tag.trialSpawnerSpawnEvent); + /// ditto + pragma(inline, true) bool isTrialSpawnerSpawnEvent() const => _tag == Tag.trialSpawnerSpawnEvent; + ///ditto + alias getTrialSpawnerSpawnEvent = _get!(Tag.trialSpawnerSpawnEvent); + + /++ + + +/ + alias villagerReputationChangeEvent = _create!(Tag.villagerReputationChangeEvent); + /// ditto + pragma(inline, true) bool isVillagerReputationChangeEvent() const => _tag == Tag.villagerReputationChangeEvent; + ///ditto + alias getVillagerReputationChangeEvent = _get!(Tag.villagerReputationChangeEvent); + + /++ + + +/ + alias asyncPlayerChatEvent = _create!(Tag.asyncPlayerChatEvent); + /// ditto + pragma(inline, true) bool isAsyncPlayerChatEvent() const => _tag == Tag.asyncPlayerChatEvent; + ///ditto + alias getAsyncPlayerChatEvent = _get!(Tag.asyncPlayerChatEvent); + + /++ + + +/ + alias asyncPlayerPreLoginEvent = _create!(Tag.asyncPlayerPreLoginEvent); + /// ditto + pragma(inline, true) bool isAsyncPlayerPreLoginEvent() const => _tag == Tag.asyncPlayerPreLoginEvent; + ///ditto + alias getAsyncPlayerPreLoginEvent = _get!(Tag.asyncPlayerPreLoginEvent); + + /++ + + +/ + alias playerAdvancementDoneEvent = _create!(Tag.playerAdvancementDoneEvent); + /// ditto + pragma(inline, true) bool isPlayerAdvancementDoneEvent() const => _tag == Tag.playerAdvancementDoneEvent; + ///ditto + alias getPlayerAdvancementDoneEvent = _get!(Tag.playerAdvancementDoneEvent); + + /++ + + +/ + alias playerAnimationEvent = _create!(Tag.playerAnimationEvent); + /// ditto + pragma(inline, true) bool isPlayerAnimationEvent() const => _tag == Tag.playerAnimationEvent; + ///ditto + alias getPlayerAnimationEvent = _get!(Tag.playerAnimationEvent); + + /++ + + +/ + alias playerArmorStandManipulateEvent = _create!(Tag.playerArmorStandManipulateEvent); + /// ditto + pragma(inline, true) bool isPlayerArmorStandManipulateEvent() const => _tag == Tag.playerArmorStandManipulateEvent; + ///ditto + alias getPlayerArmorStandManipulateEvent = _get!(Tag.playerArmorStandManipulateEvent); + + /++ + + +/ + alias playerBucketEntityEvent = _create!(Tag.playerBucketEntityEvent); + /// ditto + pragma(inline, true) bool isPlayerBucketEntityEvent() const => _tag == Tag.playerBucketEntityEvent; + ///ditto + alias getPlayerBucketEntityEvent = _get!(Tag.playerBucketEntityEvent); + + /++ + + +/ + alias playerChangedWorldEvent = _create!(Tag.playerChangedWorldEvent); + /// ditto + pragma(inline, true) bool isPlayerChangedWorldEvent() const => _tag == Tag.playerChangedWorldEvent; + ///ditto + alias getPlayerChangedWorldEvent = _get!(Tag.playerChangedWorldEvent); + + /++ + + +/ + alias playerChannelEvent = _create!(Tag.playerChannelEvent); + /// ditto + pragma(inline, true) bool isPlayerChannelEvent() const => _tag == Tag.playerChannelEvent; + ///ditto + alias getPlayerChannelEvent = _get!(Tag.playerChannelEvent); + + /++ + + +/ + alias playerCommandPreprocessEvent = _create!(Tag.playerCommandPreprocessEvent); + /// ditto + pragma(inline, true) bool isPlayerCommandPreprocessEvent() const => _tag == Tag.playerCommandPreprocessEvent; + ///ditto + alias getPlayerCommandPreprocessEvent = _get!(Tag.playerCommandPreprocessEvent); + + /++ + + +/ + alias playerEditBookEvent = _create!(Tag.playerEditBookEvent); + /// ditto + pragma(inline, true) bool isPlayerEditBookEvent() const => _tag == Tag.playerEditBookEvent; + ///ditto + alias getPlayerEditBookEvent = _get!(Tag.playerEditBookEvent); + + /++ + + +/ + alias playerElytraBoostEvent = _create!(Tag.playerElytraBoostEvent); + /// ditto + pragma(inline, true) bool isPlayerElytraBoostEvent() const => _tag == Tag.playerElytraBoostEvent; + ///ditto + alias getPlayerElytraBoostEvent = _get!(Tag.playerElytraBoostEvent); + + /++ + + +/ + alias playerExpCooldownChangeEvent = _create!(Tag.playerExpCooldownChangeEvent); + /// ditto + pragma(inline, true) bool isPlayerExpCooldownChangeEvent() const => _tag == Tag.playerExpCooldownChangeEvent; + ///ditto + alias getPlayerExpCooldownChangeEvent = _get!(Tag.playerExpCooldownChangeEvent); + + /++ + + +/ + alias playerHarvestBlockEvent = _create!(Tag.playerHarvestBlockEvent); + /// ditto + pragma(inline, true) bool isPlayerHarvestBlockEvent() const => _tag == Tag.playerHarvestBlockEvent; + ///ditto + alias getPlayerHarvestBlockEvent = _get!(Tag.playerHarvestBlockEvent); + + /++ + + +/ + alias playerHideEntityEvent = _create!(Tag.playerHideEntityEvent); + /// ditto + pragma(inline, true) bool isPlayerHideEntityEvent() const => _tag == Tag.playerHideEntityEvent; + ///ditto + alias getPlayerHideEntityEvent = _get!(Tag.playerHideEntityEvent); + + /++ + + +/ + alias playerItemBreakEvent = _create!(Tag.playerItemBreakEvent); + /// ditto + pragma(inline, true) bool isPlayerItemBreakEvent() const => _tag == Tag.playerItemBreakEvent; + ///ditto + alias getPlayerItemBreakEvent = _get!(Tag.playerItemBreakEvent); + + /++ + + +/ + alias playerItemMendEvent = _create!(Tag.playerItemMendEvent); + /// ditto + pragma(inline, true) bool isPlayerItemMendEvent() const => _tag == Tag.playerItemMendEvent; + ///ditto + alias getPlayerItemMendEvent = _get!(Tag.playerItemMendEvent); + + /++ + + +/ + alias playerKickEvent = _create!(Tag.playerKickEvent); + /// ditto + pragma(inline, true) bool isPlayerKickEvent() const => _tag == Tag.playerKickEvent; + ///ditto + alias getPlayerKickEvent = _get!(Tag.playerKickEvent); + + /++ + + +/ + alias playerLeashEntityEvent = _create!(Tag.playerLeashEntityEvent); + /// ditto + pragma(inline, true) bool isPlayerLeashEntityEvent() const => _tag == Tag.playerLeashEntityEvent; + ///ditto + alias getPlayerLeashEntityEvent = _get!(Tag.playerLeashEntityEvent); + + /++ + + +/ + alias playerLevelChangeEvent = _create!(Tag.playerLevelChangeEvent); + /// ditto + pragma(inline, true) bool isPlayerLevelChangeEvent() const => _tag == Tag.playerLevelChangeEvent; + ///ditto + alias getPlayerLevelChangeEvent = _get!(Tag.playerLevelChangeEvent); + + /++ + + +/ + alias playerLocaleChangeEvent = _create!(Tag.playerLocaleChangeEvent); + /// ditto + pragma(inline, true) bool isPlayerLocaleChangeEvent() const => _tag == Tag.playerLocaleChangeEvent; + ///ditto + alias getPlayerLocaleChangeEvent = _get!(Tag.playerLocaleChangeEvent); + + /++ + + +/ + alias playerNameEntityEvent = _create!(Tag.playerNameEntityEvent); + /// ditto + pragma(inline, true) bool isPlayerNameEntityEvent() const => _tag == Tag.playerNameEntityEvent; + ///ditto + alias getPlayerNameEntityEvent = _get!(Tag.playerNameEntityEvent); + + /++ + + +/ + alias playerOpenSignEvent = _create!(Tag.playerOpenSignEvent); + /// ditto + pragma(inline, true) bool isPlayerOpenSignEvent() const => _tag == Tag.playerOpenSignEvent; + ///ditto + alias getPlayerOpenSignEvent = _get!(Tag.playerOpenSignEvent); + + /++ + + +/ + alias playerPortalEvent = _create!(Tag.playerPortalEvent); + /// ditto + pragma(inline, true) bool isPlayerPortalEvent() const => _tag == Tag.playerPortalEvent; + ///ditto + alias getPlayerPortalEvent = _get!(Tag.playerPortalEvent); + + /++ + + +/ + alias playerPreLoginEvent = _create!(Tag.playerPreLoginEvent); + /// ditto + pragma(inline, true) bool isPlayerPreLoginEvent() const => _tag == Tag.playerPreLoginEvent; + ///ditto + alias getPlayerPreLoginEvent = _get!(Tag.playerPreLoginEvent); + + /++ + + +/ + alias playerRiptideEvent = _create!(Tag.playerRiptideEvent); + /// ditto + pragma(inline, true) bool isPlayerRiptideEvent() const => _tag == Tag.playerRiptideEvent; + ///ditto + alias getPlayerRiptideEvent = _get!(Tag.playerRiptideEvent); + + /++ + + +/ + alias playerShearEntityEvent = _create!(Tag.playerShearEntityEvent); + /// ditto + pragma(inline, true) bool isPlayerShearEntityEvent() const => _tag == Tag.playerShearEntityEvent; + ///ditto + alias getPlayerShearEntityEvent = _get!(Tag.playerShearEntityEvent); + + /++ + + +/ + alias playerShowEntityEvent = _create!(Tag.playerShowEntityEvent); + /// ditto + pragma(inline, true) bool isPlayerShowEntityEvent() const => _tag == Tag.playerShowEntityEvent; + ///ditto + alias getPlayerShowEntityEvent = _get!(Tag.playerShowEntityEvent); + + /++ + + +/ + alias playerSpawnChangeEvent = _create!(Tag.playerSpawnChangeEvent); + /// ditto + pragma(inline, true) bool isPlayerSpawnChangeEvent() const => _tag == Tag.playerSpawnChangeEvent; + ///ditto + alias getPlayerSpawnChangeEvent = _get!(Tag.playerSpawnChangeEvent); + + /++ + + +/ + alias playerStatisticIncrementEvent = _create!(Tag.playerStatisticIncrementEvent); + /// ditto + pragma(inline, true) bool isPlayerStatisticIncrementEvent() const => _tag == Tag.playerStatisticIncrementEvent; + ///ditto + alias getPlayerStatisticIncrementEvent = _get!(Tag.playerStatisticIncrementEvent); + + /++ + + +/ + alias playerSwapHandsEvent = _create!(Tag.playerSwapHandsEvent); + /// ditto + pragma(inline, true) bool isPlayerSwapHandsEvent() const => _tag == Tag.playerSwapHandsEvent; + ///ditto + alias getPlayerSwapHandsEvent = _get!(Tag.playerSwapHandsEvent); + + /++ + + +/ + alias playerTakeLecternBookEvent = _create!(Tag.playerTakeLecternBookEvent); + /// ditto + pragma(inline, true) bool isPlayerTakeLecternBookEvent() const => _tag == Tag.playerTakeLecternBookEvent; + ///ditto + alias getPlayerTakeLecternBookEvent = _get!(Tag.playerTakeLecternBookEvent); + + /++ + + +/ + alias playerUnleashEntityEvent = _create!(Tag.playerUnleashEntityEvent); + /// ditto + pragma(inline, true) bool isPlayerUnleashEntityEvent() const => _tag == Tag.playerUnleashEntityEvent; + ///ditto + alias getPlayerUnleashEntityEvent = _get!(Tag.playerUnleashEntityEvent); + + /++ + + +/ + alias playerVelocityEvent = _create!(Tag.playerVelocityEvent); + /// ditto + pragma(inline, true) bool isPlayerVelocityEvent() const => _tag == Tag.playerVelocityEvent; + ///ditto + alias getPlayerVelocityEvent = _get!(Tag.playerVelocityEvent); + + /++ + + +/ + alias playerInputEvent = _create!(Tag.playerInputEvent); + /// ditto + pragma(inline, true) bool isPlayerInputEvent() const => _tag == Tag.playerInputEvent; + ///ditto + alias getPlayerInputEvent = _get!(Tag.playerInputEvent); + + /++ + + +/ + alias playerInteractAtEntityEvent = _create!(Tag.playerInteractAtEntityEvent); + /// ditto + pragma(inline, true) bool isPlayerInteractAtEntityEvent() const => _tag == Tag.playerInteractAtEntityEvent; + ///ditto + alias getPlayerInteractAtEntityEvent = _get!(Tag.playerInteractAtEntityEvent); + + /++ + + +/ + alias playerLinksSendEvent = _create!(Tag.playerLinksSendEvent); + /// ditto + pragma(inline, true) bool isPlayerLinksSendEvent() const => _tag == Tag.playerLinksSendEvent; + ///ditto + alias getPlayerLinksSendEvent = _get!(Tag.playerLinksSendEvent); + + /++ + + +/ + alias playerPickupArrowEvent = _create!(Tag.playerPickupArrowEvent); + /// ditto + pragma(inline, true) bool isPlayerPickupArrowEvent() const => _tag == Tag.playerPickupArrowEvent; + ///ditto + alias getPlayerPickupArrowEvent = _get!(Tag.playerPickupArrowEvent); + + /++ + + +/ + alias playerRecipeBookClickEvent = _create!(Tag.playerRecipeBookClickEvent); + /// ditto + pragma(inline, true) bool isPlayerRecipeBookClickEvent() const => _tag == Tag.playerRecipeBookClickEvent; + ///ditto + alias getPlayerRecipeBookClickEvent = _get!(Tag.playerRecipeBookClickEvent); + + /++ + + +/ + alias playerRecipeBookSettingsChangeEvent = _create!(Tag.playerRecipeBookSettingsChangeEvent); + /// ditto + pragma(inline, true) bool isPlayerRecipeBookSettingsChangeEvent() const => _tag == Tag.playerRecipeBookSettingsChangeEvent; + ///ditto + alias getPlayerRecipeBookSettingsChangeEvent = _get!(Tag.playerRecipeBookSettingsChangeEvent); + + /++ + + +/ + alias playerRecipeDiscoverEvent = _create!(Tag.playerRecipeDiscoverEvent); + /// ditto + pragma(inline, true) bool isPlayerRecipeDiscoverEvent() const => _tag == Tag.playerRecipeDiscoverEvent; + ///ditto + alias getPlayerRecipeDiscoverEvent = _get!(Tag.playerRecipeDiscoverEvent); + + /++ + + +/ + alias playerRegisterChannelEvent = _create!(Tag.playerRegisterChannelEvent); + /// ditto + pragma(inline, true) bool isPlayerRegisterChannelEvent() const => _tag == Tag.playerRegisterChannelEvent; + ///ditto + alias getPlayerRegisterChannelEvent = _get!(Tag.playerRegisterChannelEvent); + + /++ + + +/ + alias playerResourcePackStatusEvent = _create!(Tag.playerResourcePackStatusEvent); + /// ditto + pragma(inline, true) bool isPlayerResourcePackStatusEvent() const => _tag == Tag.playerResourcePackStatusEvent; + ///ditto + alias getPlayerResourcePackStatusEvent = _get!(Tag.playerResourcePackStatusEvent); + + /++ + + +/ + alias playerSpawnLocationEvent = _create!(Tag.playerSpawnLocationEvent); + /// ditto + pragma(inline, true) bool isPlayerSpawnLocationEvent() const => _tag == Tag.playerSpawnLocationEvent; + ///ditto + alias getPlayerSpawnLocationEvent = _get!(Tag.playerSpawnLocationEvent); + + /++ + + +/ + alias playerUnregisterChannelEvent = _create!(Tag.playerUnregisterChannelEvent); + /// ditto + pragma(inline, true) bool isPlayerUnregisterChannelEvent() const => _tag == Tag.playerUnregisterChannelEvent; + ///ditto + alias getPlayerUnregisterChannelEvent = _get!(Tag.playerUnregisterChannelEvent); + + /++ + + +/ + alias raidFinishEvent = _create!(Tag.raidFinishEvent); + /// ditto + pragma(inline, true) bool isRaidFinishEvent() const => _tag == Tag.raidFinishEvent; + ///ditto + alias getRaidFinishEvent = _get!(Tag.raidFinishEvent); + + /++ + + +/ + alias raidSpawnWaveEvent = _create!(Tag.raidSpawnWaveEvent); + /// ditto + pragma(inline, true) bool isRaidSpawnWaveEvent() const => _tag == Tag.raidSpawnWaveEvent; + ///ditto + alias getRaidSpawnWaveEvent = _get!(Tag.raidSpawnWaveEvent); + + /++ + + +/ + alias raidStopEvent = _create!(Tag.raidStopEvent); + /// ditto + pragma(inline, true) bool isRaidStopEvent() const => _tag == Tag.raidStopEvent; + ///ditto + alias getRaidStopEvent = _get!(Tag.raidStopEvent); + + /++ + + +/ + alias raidTriggerEvent = _create!(Tag.raidTriggerEvent); + /// ditto + pragma(inline, true) bool isRaidTriggerEvent() const => _tag == Tag.raidTriggerEvent; + ///ditto + alias getRaidTriggerEvent = _get!(Tag.raidTriggerEvent); + + /++ + + +/ + alias lightningStrikeEvent = _create!(Tag.lightningStrikeEvent); + /// ditto + pragma(inline, true) bool isLightningStrikeEvent() const => _tag == Tag.lightningStrikeEvent; + ///ditto + alias getLightningStrikeEvent = _get!(Tag.lightningStrikeEvent); + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case playerChatEvent: _get!(Tag.playerChatEvent).witFree; break; + case playerCommandSendEvent: _get!(Tag.playerCommandSendEvent).witFree; break; + case playerPermissionCheckEvent: _get!(Tag.playerPermissionCheckEvent).witFree; break; + case playerCustomPayloadEvent: _get!(Tag.playerCustomPayloadEvent).witFree; break; + case playerFishEvent: _get!(Tag.playerFishEvent).witFree; break; + case playerEggThrowEvent: _get!(Tag.playerEggThrowEvent).witFree; break; + case playerInteractEvent: _get!(Tag.playerInteractEvent).witFree; break; + case blockBreakEvent: _get!(Tag.blockBreakEvent).witFree; break; + case blockBurnEvent: _get!(Tag.blockBurnEvent).witFree; break; + case blockCanBuildEvent: _get!(Tag.blockCanBuildEvent).witFree; break; + case blockGrowEvent: _get!(Tag.blockGrowEvent).witFree; break; + case blockPlaceEvent: _get!(Tag.blockPlaceEvent).witFree; break; + case dialogClickActionEvent: _get!(Tag.dialogClickActionEvent).witFree; break; + case dialogShowEvent: _get!(Tag.dialogShowEvent).witFree; break; + case bedrockFormResponseEvent: _get!(Tag.bedrockFormResponseEvent).witFree; break; + case serverCommandEvent: _get!(Tag.serverCommandEvent).witFree; break; + case serverListPingEvent: _get!(Tag.serverListPingEvent).witFree; break; + case packetReceivedEvent: _get!(Tag.packetReceivedEvent).witFree; break; + case packetSentEvent: _get!(Tag.packetSentEvent).witFree; break; + case entitySpawnEvent: _get!(Tag.entitySpawnEvent).witFree; break; + case entityDyeEvent: _get!(Tag.entityDyeEvent).witFree; break; + case entityPickupItemEvent: _get!(Tag.entityPickupItemEvent).witFree; break; + case entityShootBowEvent: _get!(Tag.entityShootBowEvent).witFree; break; + case entityTransformEvent: _get!(Tag.entityTransformEvent).witFree; break; + case playerItemConsumeEvent: _get!(Tag.playerItemConsumeEvent).witFree; break; + case playerItemDamageEvent: _get!(Tag.playerItemDamageEvent).witFree; break; + case playerDropItemEvent: _get!(Tag.playerDropItemEvent).witFree; break; + case playerBucketEmptyEvent: _get!(Tag.playerBucketEmptyEvent).witFree; break; + case playerBucketFillEvent: _get!(Tag.playerBucketFillEvent).witFree; break; + case blockDispenseEvent: _get!(Tag.blockDispenseEvent).witFree; break; + case blockPistonExtendEvent: _get!(Tag.blockPistonExtendEvent).witFree; break; + case blockPistonRetractEvent: _get!(Tag.blockPistonRetractEvent).witFree; break; + case notePlayEvent: _get!(Tag.notePlayEvent).witFree; break; + case signChangeEvent: _get!(Tag.signChangeEvent).witFree; break; + case tntPrimeEvent: _get!(Tag.tntPrimeEvent).witFree; break; + case asyncStructureGenerateEvent: _get!(Tag.asyncStructureGenerateEvent).witFree; break; + case asyncStructureSpawnEvent: _get!(Tag.asyncStructureSpawnEvent).witFree; break; + case genericGameEvent: _get!(Tag.genericGameEvent).witFree; break; + case lootGenerateEvent: _get!(Tag.lootGenerateEvent).witFree; break; + case portalCreateEvent: _get!(Tag.portalCreateEvent).witFree; break; + case structureGrowEvent: _get!(Tag.structureGrowEvent).witFree; break; + case worldSaveEvent: _get!(Tag.worldSaveEvent).witFree; break; + case craftItemEvent: _get!(Tag.craftItemEvent).witFree; break; + case furnaceSmeltEvent: _get!(Tag.furnaceSmeltEvent).witFree; break; + case furnaceBurnEvent: _get!(Tag.furnaceBurnEvent).witFree; break; + case furnaceExtractEvent: _get!(Tag.furnaceExtractEvent).witFree; break; + case furnaceStartSmeltEvent: _get!(Tag.furnaceStartSmeltEvent).witFree; break; + case inventoryCreativeEvent: _get!(Tag.inventoryCreativeEvent).witFree; break; + case inventoryMoveItemEvent: _get!(Tag.inventoryMoveItemEvent).witFree; break; + case inventoryPickupItemEvent: _get!(Tag.inventoryPickupItemEvent).witFree; break; + case prepareAnvilEvent: _get!(Tag.prepareAnvilEvent).witFree; break; + case prepareGrindstoneEvent: _get!(Tag.prepareGrindstoneEvent).witFree; break; + case prepareInventoryResultEvent: _get!(Tag.prepareInventoryResultEvent).witFree; break; + case prepareItemCraftEvent: _get!(Tag.prepareItemCraftEvent).witFree; break; + case prepareSmithingEvent: _get!(Tag.prepareSmithingEvent).witFree; break; + case smithItemEvent: _get!(Tag.smithItemEvent).witFree; break; + case prepareItemEnchantEvent: _get!(Tag.prepareItemEnchantEvent).witFree; break; + case enchantItemEvent: _get!(Tag.enchantItemEvent).witFree; break; + case hangingPlaceEvent: _get!(Tag.hangingPlaceEvent).witFree; break; + case bellRingEvent: _get!(Tag.bellRingEvent).witFree; break; + case blockDispenseLootEvent: _get!(Tag.blockDispenseLootEvent).witFree; break; + case blockDropItemEvent: _get!(Tag.blockDropItemEvent).witFree; break; + case blockFertilizeEvent: _get!(Tag.blockFertilizeEvent).witFree; break; + case blockMultiPlaceEvent: _get!(Tag.blockMultiPlaceEvent).witFree; break; + case blockReceiveGameEvent: _get!(Tag.blockReceiveGameEvent).witFree; break; + case cauldronLevelChangeEvent: _get!(Tag.cauldronLevelChangeEvent).witFree; break; + case creatureSpawnEvent: _get!(Tag.creatureSpawnEvent).witFree; break; + case enderDragonChangePhaseEvent: _get!(Tag.enderDragonChangePhaseEvent).witFree; break; + case entityChangeBlockEvent: _get!(Tag.entityChangeBlockEvent).witFree; break; + case entityDamageByBlockEvent: _get!(Tag.entityDamageByBlockEvent).witFree; break; + case entityDamageByEntityEvent: _get!(Tag.entityDamageByEntityEvent).witFree; break; + case entityDropItemEvent: _get!(Tag.entityDropItemEvent).witFree; break; + case entityPlaceEvent: _get!(Tag.entityPlaceEvent).witFree; break; + case entityPoseChangeEvent: _get!(Tag.entityPoseChangeEvent).witFree; break; + case entityPotionEffectEvent: _get!(Tag.entityPotionEffectEvent).witFree; break; + case entitySpellCastEvent: _get!(Tag.entitySpellCastEvent).witFree; break; + case entityTargetLivingEntityEvent: _get!(Tag.entityTargetLivingEntityEvent).witFree; break; + case itemSpawnEvent: _get!(Tag.itemSpawnEvent).witFree; break; + case piglinBarterEvent: _get!(Tag.piglinBarterEvent).witFree; break; + case villagerCareerChangeEvent: _get!(Tag.villagerCareerChangeEvent).witFree; break; + case areaEffectCloudApplyEvent: _get!(Tag.areaEffectCloudApplyEvent).witFree; break; + case creeperPowerEvent: _get!(Tag.creeperPowerEvent).witFree; break; + case entityRemoveEvent: _get!(Tag.entityRemoveEvent).witFree; break; + case entityUnleashEvent: _get!(Tag.entityUnleashEvent).witFree; break; + case lingeringPotionSplashEvent: _get!(Tag.lingeringPotionSplashEvent).witFree; break; + case potionSplashEvent: _get!(Tag.potionSplashEvent).witFree; break; + case asyncPlayerChatEvent: _get!(Tag.asyncPlayerChatEvent).witFree; break; + case asyncPlayerPreLoginEvent: _get!(Tag.asyncPlayerPreLoginEvent).witFree; break; + case playerAdvancementDoneEvent: _get!(Tag.playerAdvancementDoneEvent).witFree; break; + case playerAnimationEvent: _get!(Tag.playerAnimationEvent).witFree; break; + case playerBucketEntityEvent: _get!(Tag.playerBucketEntityEvent).witFree; break; + case playerChannelEvent: _get!(Tag.playerChannelEvent).witFree; break; + case playerCommandPreprocessEvent: _get!(Tag.playerCommandPreprocessEvent).witFree; break; + case playerEditBookEvent: _get!(Tag.playerEditBookEvent).witFree; break; + case playerHarvestBlockEvent: _get!(Tag.playerHarvestBlockEvent).witFree; break; + case playerItemBreakEvent: _get!(Tag.playerItemBreakEvent).witFree; break; + case playerItemMendEvent: _get!(Tag.playerItemMendEvent).witFree; break; + case playerKickEvent: _get!(Tag.playerKickEvent).witFree; break; + case playerLocaleChangeEvent: _get!(Tag.playerLocaleChangeEvent).witFree; break; + case playerPreLoginEvent: _get!(Tag.playerPreLoginEvent).witFree; break; + case playerRiptideEvent: _get!(Tag.playerRiptideEvent).witFree; break; + case playerStatisticIncrementEvent: _get!(Tag.playerStatisticIncrementEvent).witFree; break; + case playerInputEvent: _get!(Tag.playerInputEvent).witFree; break; + case playerLinksSendEvent: _get!(Tag.playerLinksSendEvent).witFree; break; + case playerRecipeBookClickEvent: _get!(Tag.playerRecipeBookClickEvent).witFree; break; + case playerRecipeBookSettingsChangeEvent: _get!(Tag.playerRecipeBookSettingsChangeEvent).witFree; break; + case playerRecipeDiscoverEvent: _get!(Tag.playerRecipeDiscoverEvent).witFree; break; + case playerRegisterChannelEvent: _get!(Tag.playerRegisterChannelEvent).witFree; break; + case playerResourcePackStatusEvent: _get!(Tag.playerResourcePackStatusEvent).witFree; break; + case playerUnregisterChannelEvent: _get!(Tag.playerUnregisterChannelEvent).witFree; break; + case raidStopEvent: _get!(Tag.raidStopEvent).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + switch (_tag) with (Tag) { + case playerJoinEvent: _get!(Tag.playerJoinEvent).witDrop; break; + case playerLeaveEvent: _get!(Tag.playerLeaveEvent).witDrop; break; + case playerLoginEvent: _get!(Tag.playerLoginEvent).witDrop; break; + case playerChatEvent: _get!(Tag.playerChatEvent).witDrop; break; + case playerCommandSendEvent: _get!(Tag.playerCommandSendEvent).witDrop; break; + case playerPermissionCheckEvent: _get!(Tag.playerPermissionCheckEvent).witDrop; break; + case playerMoveEvent: _get!(Tag.playerMoveEvent).witDrop; break; + case playerTeleportEvent: _get!(Tag.playerTeleportEvent).witDrop; break; + case playerChangeWorldEvent: _get!(Tag.playerChangeWorldEvent).witDrop; break; + case playerRespawnEvent: _get!(Tag.playerRespawnEvent).witDrop; break; + case playerExpChangeEvent: _get!(Tag.playerExpChangeEvent).witDrop; break; + case playerItemHeldEvent: _get!(Tag.playerItemHeldEvent).witDrop; break; + case playerChangedMainHandEvent: _get!(Tag.playerChangedMainHandEvent).witDrop; break; + case playerGamemodeChangeEvent: _get!(Tag.playerGamemodeChangeEvent).witDrop; break; + case playerCustomPayloadEvent: _get!(Tag.playerCustomPayloadEvent).witDrop; break; + case playerFishEvent: _get!(Tag.playerFishEvent).witDrop; break; + case playerEggThrowEvent: _get!(Tag.playerEggThrowEvent).witDrop; break; + case playerInteractUnknownEntityEvent: _get!(Tag.playerInteractUnknownEntityEvent).witDrop; break; + case playerInteractEntityEvent: _get!(Tag.playerInteractEntityEvent).witDrop; break; + case playerInteractEvent: _get!(Tag.playerInteractEvent).witDrop; break; + case playerToggleSneakEvent: _get!(Tag.playerToggleSneakEvent).witDrop; break; + case playerToggleFlightEvent: _get!(Tag.playerToggleFlightEvent).witDrop; break; + case playerToggleSprintEvent: _get!(Tag.playerToggleSprintEvent).witDrop; break; + case inventoryClickEvent: _get!(Tag.inventoryClickEvent).witDrop; break; + case inventoryCloseEvent: _get!(Tag.inventoryCloseEvent).witDrop; break; + case blockRedstoneEvent: _get!(Tag.blockRedstoneEvent).witDrop; break; + case blockBreakEvent: _get!(Tag.blockBreakEvent).witDrop; break; + case blockCanBuildEvent: _get!(Tag.blockCanBuildEvent).witDrop; break; + case blockGrowEvent: _get!(Tag.blockGrowEvent).witDrop; break; + case blockPlaceEvent: _get!(Tag.blockPlaceEvent).witDrop; break; + case dialogClickActionEvent: _get!(Tag.dialogClickActionEvent).witDrop; break; + case dialogShowEvent: _get!(Tag.dialogShowEvent).witDrop; break; + case dialogClearEvent: _get!(Tag.dialogClearEvent).witDrop; break; + case bedrockFormResponseEvent: _get!(Tag.bedrockFormResponseEvent).witDrop; break; + case serverListPingEvent: _get!(Tag.serverListPingEvent).witDrop; break; + case spawnChangeEvent: _get!(Tag.spawnChangeEvent).witDrop; break; + case serverBroadcastEvent: _get!(Tag.serverBroadcastEvent).witDrop; break; + case packetReceivedEvent: _get!(Tag.packetReceivedEvent).witDrop; break; + case packetSentEvent: _get!(Tag.packetSentEvent).witDrop; break; + case chunkLoadEvent: _get!(Tag.chunkLoadEvent).witDrop; break; + case chunkSaveEvent: _get!(Tag.chunkSaveEvent).witDrop; break; + case chunkSendEvent: _get!(Tag.chunkSendEvent).witDrop; break; + case playerDeathEvent: _get!(Tag.playerDeathEvent).witDrop; break; + case entitySpawnEvent: _get!(Tag.entitySpawnEvent).witDrop; break; + case entityDyeEvent: _get!(Tag.entityDyeEvent).witDrop; break; + case entityTameEvent: _get!(Tag.entityTameEvent).witDrop; break; + case playerItemConsumeEvent: _get!(Tag.playerItemConsumeEvent).witDrop; break; + case playerItemDamageEvent: _get!(Tag.playerItemDamageEvent).witDrop; break; + case playerDropItemEvent: _get!(Tag.playerDropItemEvent).witDrop; break; + case playerBedEnterEvent: _get!(Tag.playerBedEnterEvent).witDrop; break; + case playerBedLeaveEvent: _get!(Tag.playerBedLeaveEvent).witDrop; break; + case playerBucketEmptyEvent: _get!(Tag.playerBucketEmptyEvent).witDrop; break; + case playerBucketFillEvent: _get!(Tag.playerBucketFillEvent).witDrop; break; + case blockDamageEvent: _get!(Tag.blockDamageEvent).witDrop; break; + case signChangeEvent: _get!(Tag.signChangeEvent).witDrop; break; + case weatherChangeEvent: _get!(Tag.weatherChangeEvent).witDrop; break; + case thunderChangeEvent: _get!(Tag.thunderChangeEvent).witDrop; break; + case worldLoadEvent: _get!(Tag.worldLoadEvent).witDrop; break; + case worldUnloadEvent: _get!(Tag.worldUnloadEvent).witDrop; break; + case worldInitEvent: _get!(Tag.worldInitEvent).witDrop; break; + case inventoryOpenEvent: _get!(Tag.inventoryOpenEvent).witDrop; break; + case inventoryDragEvent: _get!(Tag.inventoryDragEvent).witDrop; break; + case craftItemEvent: _get!(Tag.craftItemEvent).witDrop; break; + case furnaceExtractEvent: _get!(Tag.furnaceExtractEvent).witDrop; break; + case inventoryCreativeEvent: _get!(Tag.inventoryCreativeEvent).witDrop; break; + case inventoryInteractEvent: _get!(Tag.inventoryInteractEvent).witDrop; break; + case prepareAnvilEvent: _get!(Tag.prepareAnvilEvent).witDrop; break; + case prepareGrindstoneEvent: _get!(Tag.prepareGrindstoneEvent).witDrop; break; + case prepareInventoryResultEvent: _get!(Tag.prepareInventoryResultEvent).witDrop; break; + case prepareItemCraftEvent: _get!(Tag.prepareItemCraftEvent).witDrop; break; + case prepareSmithingEvent: _get!(Tag.prepareSmithingEvent).witDrop; break; + case smithItemEvent: _get!(Tag.smithItemEvent).witDrop; break; + case tradeSelectEvent: _get!(Tag.tradeSelectEvent).witDrop; break; + case prepareItemEnchantEvent: _get!(Tag.prepareItemEnchantEvent).witDrop; break; + case enchantItemEvent: _get!(Tag.enchantItemEvent).witDrop; break; + case hangingPlaceEvent: _get!(Tag.hangingPlaceEvent).witDrop; break; + case bellResonateEvent: _get!(Tag.bellResonateEvent).witDrop; break; + case bellRingEvent: _get!(Tag.bellRingEvent).witDrop; break; + case blockBrushEvent: _get!(Tag.blockBrushEvent).witDrop; break; + case blockCookEvent: _get!(Tag.blockCookEvent).witDrop; break; + case blockDamageAbortEvent: _get!(Tag.blockDamageAbortEvent).witDrop; break; + case blockDispenseArmorEvent: _get!(Tag.blockDispenseArmorEvent).witDrop; break; + case blockDispenseLootEvent: _get!(Tag.blockDispenseLootEvent).witDrop; break; + case blockDropItemEvent: _get!(Tag.blockDropItemEvent).witDrop; break; + case blockExpEvent: _get!(Tag.blockExpEvent).witDrop; break; + case blockFertilizeEvent: _get!(Tag.blockFertilizeEvent).witDrop; break; + case blockMultiPlaceEvent: _get!(Tag.blockMultiPlaceEvent).witDrop; break; + case blockReceiveGameEvent: _get!(Tag.blockReceiveGameEvent).witDrop; break; + case blockShearEntityEvent: _get!(Tag.blockShearEntityEvent).witDrop; break; + case blockSpreadEvent: _get!(Tag.blockSpreadEvent).witDrop; break; + case brewingStartEvent: _get!(Tag.brewingStartEvent).witDrop; break; + case campfireStartEvent: _get!(Tag.campfireStartEvent).witDrop; break; + case cauldronLevelChangeEvent: _get!(Tag.cauldronLevelChangeEvent).witDrop; break; + case crafterCraftEvent: _get!(Tag.crafterCraftEvent).witDrop; break; + case entityBlockFormEvent: _get!(Tag.entityBlockFormEvent).witDrop; break; + case fluidLevelChangeEvent: _get!(Tag.fluidLevelChangeEvent).witDrop; break; + case inventoryBlockStartEvent: _get!(Tag.inventoryBlockStartEvent).witDrop; break; + case leavesDecayEvent: _get!(Tag.leavesDecayEvent).witDrop; break; + case moistureChangeEvent: _get!(Tag.moistureChangeEvent).witDrop; break; + case sculkBloomEvent: _get!(Tag.sculkBloomEvent).witDrop; break; + case vaultDisplayItemEvent: _get!(Tag.vaultDisplayItemEvent).witDrop; break; + case creatureSpawnEvent: _get!(Tag.creatureSpawnEvent).witDrop; break; + case piglinBarterEvent: _get!(Tag.piglinBarterEvent).witDrop; break; + case asyncPlayerChatEvent: _get!(Tag.asyncPlayerChatEvent).witDrop; break; + case asyncPlayerPreLoginEvent: _get!(Tag.asyncPlayerPreLoginEvent).witDrop; break; + case playerAdvancementDoneEvent: _get!(Tag.playerAdvancementDoneEvent).witDrop; break; + case playerAnimationEvent: _get!(Tag.playerAnimationEvent).witDrop; break; + case playerArmorStandManipulateEvent: _get!(Tag.playerArmorStandManipulateEvent).witDrop; break; + case playerBucketEntityEvent: _get!(Tag.playerBucketEntityEvent).witDrop; break; + case playerChangedWorldEvent: _get!(Tag.playerChangedWorldEvent).witDrop; break; + case playerChannelEvent: _get!(Tag.playerChannelEvent).witDrop; break; + case playerCommandPreprocessEvent: _get!(Tag.playerCommandPreprocessEvent).witDrop; break; + case playerEditBookEvent: _get!(Tag.playerEditBookEvent).witDrop; break; + case playerElytraBoostEvent: _get!(Tag.playerElytraBoostEvent).witDrop; break; + case playerExpCooldownChangeEvent: _get!(Tag.playerExpCooldownChangeEvent).witDrop; break; + case playerHarvestBlockEvent: _get!(Tag.playerHarvestBlockEvent).witDrop; break; + case playerHideEntityEvent: _get!(Tag.playerHideEntityEvent).witDrop; break; + case playerItemBreakEvent: _get!(Tag.playerItemBreakEvent).witDrop; break; + case playerItemMendEvent: _get!(Tag.playerItemMendEvent).witDrop; break; + case playerKickEvent: _get!(Tag.playerKickEvent).witDrop; break; + case playerLeashEntityEvent: _get!(Tag.playerLeashEntityEvent).witDrop; break; + case playerLevelChangeEvent: _get!(Tag.playerLevelChangeEvent).witDrop; break; + case playerLocaleChangeEvent: _get!(Tag.playerLocaleChangeEvent).witDrop; break; + case playerNameEntityEvent: _get!(Tag.playerNameEntityEvent).witDrop; break; + case playerOpenSignEvent: _get!(Tag.playerOpenSignEvent).witDrop; break; + case playerPortalEvent: _get!(Tag.playerPortalEvent).witDrop; break; + case playerPreLoginEvent: _get!(Tag.playerPreLoginEvent).witDrop; break; + case playerRiptideEvent: _get!(Tag.playerRiptideEvent).witDrop; break; + case playerShearEntityEvent: _get!(Tag.playerShearEntityEvent).witDrop; break; + case playerShowEntityEvent: _get!(Tag.playerShowEntityEvent).witDrop; break; + case playerSpawnChangeEvent: _get!(Tag.playerSpawnChangeEvent).witDrop; break; + case playerStatisticIncrementEvent: _get!(Tag.playerStatisticIncrementEvent).witDrop; break; + case playerSwapHandsEvent: _get!(Tag.playerSwapHandsEvent).witDrop; break; + case playerTakeLecternBookEvent: _get!(Tag.playerTakeLecternBookEvent).witDrop; break; + case playerUnleashEntityEvent: _get!(Tag.playerUnleashEntityEvent).witDrop; break; + case playerVelocityEvent: _get!(Tag.playerVelocityEvent).witDrop; break; + case playerInputEvent: _get!(Tag.playerInputEvent).witDrop; break; + case playerInteractAtEntityEvent: _get!(Tag.playerInteractAtEntityEvent).witDrop; break; + case playerLinksSendEvent: _get!(Tag.playerLinksSendEvent).witDrop; break; + case playerPickupArrowEvent: _get!(Tag.playerPickupArrowEvent).witDrop; break; + case playerRecipeBookClickEvent: _get!(Tag.playerRecipeBookClickEvent).witDrop; break; + case playerRecipeBookSettingsChangeEvent: _get!(Tag.playerRecipeBookSettingsChangeEvent).witDrop; break; + case playerRecipeDiscoverEvent: _get!(Tag.playerRecipeDiscoverEvent).witDrop; break; + case playerRegisterChannelEvent: _get!(Tag.playerRegisterChannelEvent).witDrop; break; + case playerResourcePackStatusEvent: _get!(Tag.playerResourcePackStatusEvent).witDrop; break; + case playerSpawnLocationEvent: _get!(Tag.playerSpawnLocationEvent).witDrop; break; + case playerUnregisterChannelEvent: _get!(Tag.playerUnregisterChannelEvent).witDrop; break; + default: break; + } + } + + Event witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.playerJoinEvent: return _create!(Tag.playerJoinEvent)(this._get!(Tag.playerJoinEvent).witClone); break; + case Tag.playerLeaveEvent: return _create!(Tag.playerLeaveEvent)(this._get!(Tag.playerLeaveEvent).witClone); break; + case Tag.playerLoginEvent: return _create!(Tag.playerLoginEvent)(this._get!(Tag.playerLoginEvent).witClone); break; + case Tag.playerChatEvent: return _create!(Tag.playerChatEvent)(this._get!(Tag.playerChatEvent).witClone); break; + case Tag.playerCommandSendEvent: return _create!(Tag.playerCommandSendEvent)(this._get!(Tag.playerCommandSendEvent).witClone); break; + case Tag.playerPermissionCheckEvent: return _create!(Tag.playerPermissionCheckEvent)(this._get!(Tag.playerPermissionCheckEvent).witClone); break; + case Tag.playerMoveEvent: return _create!(Tag.playerMoveEvent)(this._get!(Tag.playerMoveEvent).witClone); break; + case Tag.playerTeleportEvent: return _create!(Tag.playerTeleportEvent)(this._get!(Tag.playerTeleportEvent).witClone); break; + case Tag.playerChangeWorldEvent: return _create!(Tag.playerChangeWorldEvent)(this._get!(Tag.playerChangeWorldEvent).witClone); break; + case Tag.playerRespawnEvent: return _create!(Tag.playerRespawnEvent)(this._get!(Tag.playerRespawnEvent).witClone); break; + case Tag.playerExpChangeEvent: return _create!(Tag.playerExpChangeEvent)(this._get!(Tag.playerExpChangeEvent).witClone); break; + case Tag.playerItemHeldEvent: return _create!(Tag.playerItemHeldEvent)(this._get!(Tag.playerItemHeldEvent).witClone); break; + case Tag.playerChangedMainHandEvent: return _create!(Tag.playerChangedMainHandEvent)(this._get!(Tag.playerChangedMainHandEvent).witClone); break; + case Tag.playerGamemodeChangeEvent: return _create!(Tag.playerGamemodeChangeEvent)(this._get!(Tag.playerGamemodeChangeEvent).witClone); break; + case Tag.playerCustomPayloadEvent: return _create!(Tag.playerCustomPayloadEvent)(this._get!(Tag.playerCustomPayloadEvent).witClone); break; + case Tag.playerFishEvent: return _create!(Tag.playerFishEvent)(this._get!(Tag.playerFishEvent).witClone); break; + case Tag.playerEggThrowEvent: return _create!(Tag.playerEggThrowEvent)(this._get!(Tag.playerEggThrowEvent).witClone); break; + case Tag.playerInteractUnknownEntityEvent: return _create!(Tag.playerInteractUnknownEntityEvent)(this._get!(Tag.playerInteractUnknownEntityEvent).witClone); break; + case Tag.playerInteractEntityEvent: return _create!(Tag.playerInteractEntityEvent)(this._get!(Tag.playerInteractEntityEvent).witClone); break; + case Tag.playerInteractEvent: return _create!(Tag.playerInteractEvent)(this._get!(Tag.playerInteractEvent).witClone); break; + case Tag.playerToggleSneakEvent: return _create!(Tag.playerToggleSneakEvent)(this._get!(Tag.playerToggleSneakEvent).witClone); break; + case Tag.playerToggleFlightEvent: return _create!(Tag.playerToggleFlightEvent)(this._get!(Tag.playerToggleFlightEvent).witClone); break; + case Tag.playerToggleSprintEvent: return _create!(Tag.playerToggleSprintEvent)(this._get!(Tag.playerToggleSprintEvent).witClone); break; + case Tag.inventoryClickEvent: return _create!(Tag.inventoryClickEvent)(this._get!(Tag.inventoryClickEvent).witClone); break; + case Tag.inventoryCloseEvent: return _create!(Tag.inventoryCloseEvent)(this._get!(Tag.inventoryCloseEvent).witClone); break; + case Tag.blockRedstoneEvent: return _create!(Tag.blockRedstoneEvent)(this._get!(Tag.blockRedstoneEvent).witClone); break; + case Tag.blockBreakEvent: return _create!(Tag.blockBreakEvent)(this._get!(Tag.blockBreakEvent).witClone); break; + case Tag.blockBurnEvent: return _create!(Tag.blockBurnEvent)(this._get!(Tag.blockBurnEvent).witClone); break; + case Tag.blockCanBuildEvent: return _create!(Tag.blockCanBuildEvent)(this._get!(Tag.blockCanBuildEvent).witClone); break; + case Tag.blockGrowEvent: return _create!(Tag.blockGrowEvent)(this._get!(Tag.blockGrowEvent).witClone); break; + case Tag.blockPlaceEvent: return _create!(Tag.blockPlaceEvent)(this._get!(Tag.blockPlaceEvent).witClone); break; + case Tag.dialogClickActionEvent: return _create!(Tag.dialogClickActionEvent)(this._get!(Tag.dialogClickActionEvent).witClone); break; + case Tag.dialogShowEvent: return _create!(Tag.dialogShowEvent)(this._get!(Tag.dialogShowEvent).witClone); break; + case Tag.dialogClearEvent: return _create!(Tag.dialogClearEvent)(this._get!(Tag.dialogClearEvent).witClone); break; + case Tag.bedrockFormResponseEvent: return _create!(Tag.bedrockFormResponseEvent)(this._get!(Tag.bedrockFormResponseEvent).witClone); break; + case Tag.serverCommandEvent: return _create!(Tag.serverCommandEvent)(this._get!(Tag.serverCommandEvent).witClone); break; + case Tag.serverListPingEvent: return _create!(Tag.serverListPingEvent)(this._get!(Tag.serverListPingEvent).witClone); break; + case Tag.serverLoadEvent: return _create!(Tag.serverLoadEvent)(this._get!(Tag.serverLoadEvent).witClone); break; + case Tag.spawnChangeEvent: return _create!(Tag.spawnChangeEvent)(this._get!(Tag.spawnChangeEvent).witClone); break; + case Tag.serverBroadcastEvent: return _create!(Tag.serverBroadcastEvent)(this._get!(Tag.serverBroadcastEvent).witClone); break; + case Tag.serverTickStartEvent: return _create!(Tag.serverTickStartEvent)(this._get!(Tag.serverTickStartEvent).witClone); break; + case Tag.serverTickEndEvent: return _create!(Tag.serverTickEndEvent)(this._get!(Tag.serverTickEndEvent).witClone); break; + case Tag.packetReceivedEvent: return _create!(Tag.packetReceivedEvent)(this._get!(Tag.packetReceivedEvent).witClone); break; + case Tag.packetSentEvent: return _create!(Tag.packetSentEvent)(this._get!(Tag.packetSentEvent).witClone); break; + case Tag.chunkLoadEvent: return _create!(Tag.chunkLoadEvent)(this._get!(Tag.chunkLoadEvent).witClone); break; + case Tag.chunkSaveEvent: return _create!(Tag.chunkSaveEvent)(this._get!(Tag.chunkSaveEvent).witClone); break; + case Tag.chunkSendEvent: return _create!(Tag.chunkSendEvent)(this._get!(Tag.chunkSendEvent).witClone); break; + case Tag.entityDamageEvent: return _create!(Tag.entityDamageEvent)(this._get!(Tag.entityDamageEvent).witClone); break; + case Tag.entityDeathEvent: return _create!(Tag.entityDeathEvent)(this._get!(Tag.entityDeathEvent).witClone); break; + case Tag.playerDeathEvent: return _create!(Tag.playerDeathEvent)(this._get!(Tag.playerDeathEvent).witClone); break; + case Tag.entitySpawnEvent: return _create!(Tag.entitySpawnEvent)(this._get!(Tag.entitySpawnEvent).witClone); break; + case Tag.entityCombustEvent: return _create!(Tag.entityCombustEvent)(this._get!(Tag.entityCombustEvent).witClone); break; + case Tag.entityRegainHealthEvent: return _create!(Tag.entityRegainHealthEvent)(this._get!(Tag.entityRegainHealthEvent).witClone); break; + case Tag.entityAirChangeEvent: return _create!(Tag.entityAirChangeEvent)(this._get!(Tag.entityAirChangeEvent).witClone); break; + case Tag.entityBreedEvent: return _create!(Tag.entityBreedEvent)(this._get!(Tag.entityBreedEvent).witClone); break; + case Tag.entityDismountEvent: return _create!(Tag.entityDismountEvent)(this._get!(Tag.entityDismountEvent).witClone); break; + case Tag.entityDyeEvent: return _create!(Tag.entityDyeEvent)(this._get!(Tag.entityDyeEvent).witClone); break; + case Tag.entityEnterLoveModeEvent: return _create!(Tag.entityEnterLoveModeEvent)(this._get!(Tag.entityEnterLoveModeEvent).witClone); break; + case Tag.entityExplodeEvent: return _create!(Tag.entityExplodeEvent)(this._get!(Tag.entityExplodeEvent).witClone); break; + case Tag.entityMountEvent: return _create!(Tag.entityMountEvent)(this._get!(Tag.entityMountEvent).witClone); break; + case Tag.entityPickupItemEvent: return _create!(Tag.entityPickupItemEvent)(this._get!(Tag.entityPickupItemEvent).witClone); break; + case Tag.entityPortalEvent: return _create!(Tag.entityPortalEvent)(this._get!(Tag.entityPortalEvent).witClone); break; + case Tag.entityResurrectEvent: return _create!(Tag.entityResurrectEvent)(this._get!(Tag.entityResurrectEvent).witClone); break; + case Tag.entityShootBowEvent: return _create!(Tag.entityShootBowEvent)(this._get!(Tag.entityShootBowEvent).witClone); break; + case Tag.entityTameEvent: return _create!(Tag.entityTameEvent)(this._get!(Tag.entityTameEvent).witClone); break; + case Tag.entityTargetEvent: return _create!(Tag.entityTargetEvent)(this._get!(Tag.entityTargetEvent).witClone); break; + case Tag.entityTeleportEvent: return _create!(Tag.entityTeleportEvent)(this._get!(Tag.entityTeleportEvent).witClone); break; + case Tag.entityToggleGlideEvent: return _create!(Tag.entityToggleGlideEvent)(this._get!(Tag.entityToggleGlideEvent).witClone); break; + case Tag.entityTransformEvent: return _create!(Tag.entityTransformEvent)(this._get!(Tag.entityTransformEvent).witClone); break; + case Tag.playerItemConsumeEvent: return _create!(Tag.playerItemConsumeEvent)(this._get!(Tag.playerItemConsumeEvent).witClone); break; + case Tag.playerItemDamageEvent: return _create!(Tag.playerItemDamageEvent)(this._get!(Tag.playerItemDamageEvent).witClone); break; + case Tag.playerDropItemEvent: return _create!(Tag.playerDropItemEvent)(this._get!(Tag.playerDropItemEvent).witClone); break; + case Tag.playerBedEnterEvent: return _create!(Tag.playerBedEnterEvent)(this._get!(Tag.playerBedEnterEvent).witClone); break; + case Tag.playerBedLeaveEvent: return _create!(Tag.playerBedLeaveEvent)(this._get!(Tag.playerBedLeaveEvent).witClone); break; + case Tag.playerBucketEmptyEvent: return _create!(Tag.playerBucketEmptyEvent)(this._get!(Tag.playerBucketEmptyEvent).witClone); break; + case Tag.playerBucketFillEvent: return _create!(Tag.playerBucketFillEvent)(this._get!(Tag.playerBucketFillEvent).witClone); break; + case Tag.blockDamageEvent: return _create!(Tag.blockDamageEvent)(this._get!(Tag.blockDamageEvent).witClone); break; + case Tag.blockIgniteEvent: return _create!(Tag.blockIgniteEvent)(this._get!(Tag.blockIgniteEvent).witClone); break; + case Tag.blockFromToEvent: return _create!(Tag.blockFromToEvent)(this._get!(Tag.blockFromToEvent).witClone); break; + case Tag.blockFormEvent: return _create!(Tag.blockFormEvent)(this._get!(Tag.blockFormEvent).witClone); break; + case Tag.blockFadeEvent: return _create!(Tag.blockFadeEvent)(this._get!(Tag.blockFadeEvent).witClone); break; + case Tag.blockDispenseEvent: return _create!(Tag.blockDispenseEvent)(this._get!(Tag.blockDispenseEvent).witClone); break; + case Tag.blockExplodeEvent: return _create!(Tag.blockExplodeEvent)(this._get!(Tag.blockExplodeEvent).witClone); break; + case Tag.blockPhysicsEvent: return _create!(Tag.blockPhysicsEvent)(this._get!(Tag.blockPhysicsEvent).witClone); break; + case Tag.blockPistonExtendEvent: return _create!(Tag.blockPistonExtendEvent)(this._get!(Tag.blockPistonExtendEvent).witClone); break; + case Tag.blockPistonRetractEvent: return _create!(Tag.blockPistonRetractEvent)(this._get!(Tag.blockPistonRetractEvent).witClone); break; + case Tag.notePlayEvent: return _create!(Tag.notePlayEvent)(this._get!(Tag.notePlayEvent).witClone); break; + case Tag.signChangeEvent: return _create!(Tag.signChangeEvent)(this._get!(Tag.signChangeEvent).witClone); break; + case Tag.spongeAbsorbEvent: return _create!(Tag.spongeAbsorbEvent)(this._get!(Tag.spongeAbsorbEvent).witClone); break; + case Tag.tntPrimeEvent: return _create!(Tag.tntPrimeEvent)(this._get!(Tag.tntPrimeEvent).witClone); break; + case Tag.weatherChangeEvent: return _create!(Tag.weatherChangeEvent)(this._get!(Tag.weatherChangeEvent).witClone); break; + case Tag.thunderChangeEvent: return _create!(Tag.thunderChangeEvent)(this._get!(Tag.thunderChangeEvent).witClone); break; + case Tag.worldLoadEvent: return _create!(Tag.worldLoadEvent)(this._get!(Tag.worldLoadEvent).witClone); break; + case Tag.worldUnloadEvent: return _create!(Tag.worldUnloadEvent)(this._get!(Tag.worldUnloadEvent).witClone); break; + case Tag.asyncStructureGenerateEvent: return _create!(Tag.asyncStructureGenerateEvent)(this._get!(Tag.asyncStructureGenerateEvent).witClone); break; + case Tag.asyncStructureSpawnEvent: return _create!(Tag.asyncStructureSpawnEvent)(this._get!(Tag.asyncStructureSpawnEvent).witClone); break; + case Tag.chunkPopulateEvent: return _create!(Tag.chunkPopulateEvent)(this._get!(Tag.chunkPopulateEvent).witClone); break; + case Tag.chunkUnloadEvent: return _create!(Tag.chunkUnloadEvent)(this._get!(Tag.chunkUnloadEvent).witClone); break; + case Tag.entitiesLoadEvent: return _create!(Tag.entitiesLoadEvent)(this._get!(Tag.entitiesLoadEvent).witClone); break; + case Tag.entitiesUnloadEvent: return _create!(Tag.entitiesUnloadEvent)(this._get!(Tag.entitiesUnloadEvent).witClone); break; + case Tag.genericGameEvent: return _create!(Tag.genericGameEvent)(this._get!(Tag.genericGameEvent).witClone); break; + case Tag.lootGenerateEvent: return _create!(Tag.lootGenerateEvent)(this._get!(Tag.lootGenerateEvent).witClone); break; + case Tag.portalCreateEvent: return _create!(Tag.portalCreateEvent)(this._get!(Tag.portalCreateEvent).witClone); break; + case Tag.structureGrowEvent: return _create!(Tag.structureGrowEvent)(this._get!(Tag.structureGrowEvent).witClone); break; + case Tag.timeSkipEvent: return _create!(Tag.timeSkipEvent)(this._get!(Tag.timeSkipEvent).witClone); break; + case Tag.worldInitEvent: return _create!(Tag.worldInitEvent)(this._get!(Tag.worldInitEvent).witClone); break; + case Tag.worldSaveEvent: return _create!(Tag.worldSaveEvent)(this._get!(Tag.worldSaveEvent).witClone); break; + case Tag.inventoryOpenEvent: return _create!(Tag.inventoryOpenEvent)(this._get!(Tag.inventoryOpenEvent).witClone); break; + case Tag.inventoryDragEvent: return _create!(Tag.inventoryDragEvent)(this._get!(Tag.inventoryDragEvent).witClone); break; + case Tag.craftItemEvent: return _create!(Tag.craftItemEvent)(this._get!(Tag.craftItemEvent).witClone); break; + case Tag.furnaceSmeltEvent: return _create!(Tag.furnaceSmeltEvent)(this._get!(Tag.furnaceSmeltEvent).witClone); break; + case Tag.brewEvent: return _create!(Tag.brewEvent)(this._get!(Tag.brewEvent).witClone); break; + case Tag.brewingStandFuelEvent: return _create!(Tag.brewingStandFuelEvent)(this._get!(Tag.brewingStandFuelEvent).witClone); break; + case Tag.furnaceBurnEvent: return _create!(Tag.furnaceBurnEvent)(this._get!(Tag.furnaceBurnEvent).witClone); break; + case Tag.furnaceExtractEvent: return _create!(Tag.furnaceExtractEvent)(this._get!(Tag.furnaceExtractEvent).witClone); break; + case Tag.furnaceStartSmeltEvent: return _create!(Tag.furnaceStartSmeltEvent)(this._get!(Tag.furnaceStartSmeltEvent).witClone); break; + case Tag.hopperInventorySearchEvent: return _create!(Tag.hopperInventorySearchEvent)(this._get!(Tag.hopperInventorySearchEvent).witClone); break; + case Tag.inventoryCreativeEvent: return _create!(Tag.inventoryCreativeEvent)(this._get!(Tag.inventoryCreativeEvent).witClone); break; + case Tag.inventoryInteractEvent: return _create!(Tag.inventoryInteractEvent)(this._get!(Tag.inventoryInteractEvent).witClone); break; + case Tag.inventoryMoveItemEvent: return _create!(Tag.inventoryMoveItemEvent)(this._get!(Tag.inventoryMoveItemEvent).witClone); break; + case Tag.inventoryPickupItemEvent: return _create!(Tag.inventoryPickupItemEvent)(this._get!(Tag.inventoryPickupItemEvent).witClone); break; + case Tag.prepareAnvilEvent: return _create!(Tag.prepareAnvilEvent)(this._get!(Tag.prepareAnvilEvent).witClone); break; + case Tag.prepareGrindstoneEvent: return _create!(Tag.prepareGrindstoneEvent)(this._get!(Tag.prepareGrindstoneEvent).witClone); break; + case Tag.prepareInventoryResultEvent: return _create!(Tag.prepareInventoryResultEvent)(this._get!(Tag.prepareInventoryResultEvent).witClone); break; + case Tag.prepareItemCraftEvent: return _create!(Tag.prepareItemCraftEvent)(this._get!(Tag.prepareItemCraftEvent).witClone); break; + case Tag.prepareSmithingEvent: return _create!(Tag.prepareSmithingEvent)(this._get!(Tag.prepareSmithingEvent).witClone); break; + case Tag.smithItemEvent: return _create!(Tag.smithItemEvent)(this._get!(Tag.smithItemEvent).witClone); break; + case Tag.tradeSelectEvent: return _create!(Tag.tradeSelectEvent)(this._get!(Tag.tradeSelectEvent).witClone); break; + case Tag.vehicleBlockCollisionEvent: return _create!(Tag.vehicleBlockCollisionEvent)(this._get!(Tag.vehicleBlockCollisionEvent).witClone); break; + case Tag.vehicleCollisionEvent: return _create!(Tag.vehicleCollisionEvent)(this._get!(Tag.vehicleCollisionEvent).witClone); break; + case Tag.vehicleCreateEvent: return _create!(Tag.vehicleCreateEvent)(this._get!(Tag.vehicleCreateEvent).witClone); break; + case Tag.vehicleDamageEvent: return _create!(Tag.vehicleDamageEvent)(this._get!(Tag.vehicleDamageEvent).witClone); break; + case Tag.vehicleDestroyEvent: return _create!(Tag.vehicleDestroyEvent)(this._get!(Tag.vehicleDestroyEvent).witClone); break; + case Tag.vehicleEnterEvent: return _create!(Tag.vehicleEnterEvent)(this._get!(Tag.vehicleEnterEvent).witClone); break; + case Tag.vehicleEntityCollisionEvent: return _create!(Tag.vehicleEntityCollisionEvent)(this._get!(Tag.vehicleEntityCollisionEvent).witClone); break; + case Tag.vehicleExitEvent: return _create!(Tag.vehicleExitEvent)(this._get!(Tag.vehicleExitEvent).witClone); break; + case Tag.vehicleMoveEvent: return _create!(Tag.vehicleMoveEvent)(this._get!(Tag.vehicleMoveEvent).witClone); break; + case Tag.vehicleUpdateEvent: return _create!(Tag.vehicleUpdateEvent)(this._get!(Tag.vehicleUpdateEvent).witClone); break; + case Tag.prepareItemEnchantEvent: return _create!(Tag.prepareItemEnchantEvent)(this._get!(Tag.prepareItemEnchantEvent).witClone); break; + case Tag.enchantItemEvent: return _create!(Tag.enchantItemEvent)(this._get!(Tag.enchantItemEvent).witClone); break; + case Tag.mapInitializeEvent: return _create!(Tag.mapInitializeEvent)(this._get!(Tag.mapInitializeEvent).witClone); break; + case Tag.hangingBreakEvent: return _create!(Tag.hangingBreakEvent)(this._get!(Tag.hangingBreakEvent).witClone); break; + case Tag.hangingBreakByEntityEvent: return _create!(Tag.hangingBreakByEntityEvent)(this._get!(Tag.hangingBreakByEntityEvent).witClone); break; + case Tag.hangingPlaceEvent: return _create!(Tag.hangingPlaceEvent)(this._get!(Tag.hangingPlaceEvent).witClone); break; + case Tag.bellResonateEvent: return _create!(Tag.bellResonateEvent)(this._get!(Tag.bellResonateEvent).witClone); break; + case Tag.bellRingEvent: return _create!(Tag.bellRingEvent)(this._get!(Tag.bellRingEvent).witClone); break; + case Tag.blockBrushEvent: return _create!(Tag.blockBrushEvent)(this._get!(Tag.blockBrushEvent).witClone); break; + case Tag.blockCookEvent: return _create!(Tag.blockCookEvent)(this._get!(Tag.blockCookEvent).witClone); break; + case Tag.blockDamageAbortEvent: return _create!(Tag.blockDamageAbortEvent)(this._get!(Tag.blockDamageAbortEvent).witClone); break; + case Tag.blockDispenseArmorEvent: return _create!(Tag.blockDispenseArmorEvent)(this._get!(Tag.blockDispenseArmorEvent).witClone); break; + case Tag.blockDispenseLootEvent: return _create!(Tag.blockDispenseLootEvent)(this._get!(Tag.blockDispenseLootEvent).witClone); break; + case Tag.blockDropItemEvent: return _create!(Tag.blockDropItemEvent)(this._get!(Tag.blockDropItemEvent).witClone); break; + case Tag.blockExpEvent: return _create!(Tag.blockExpEvent)(this._get!(Tag.blockExpEvent).witClone); break; + case Tag.blockFertilizeEvent: return _create!(Tag.blockFertilizeEvent)(this._get!(Tag.blockFertilizeEvent).witClone); break; + case Tag.blockMultiPlaceEvent: return _create!(Tag.blockMultiPlaceEvent)(this._get!(Tag.blockMultiPlaceEvent).witClone); break; + case Tag.blockReceiveGameEvent: return _create!(Tag.blockReceiveGameEvent)(this._get!(Tag.blockReceiveGameEvent).witClone); break; + case Tag.blockShearEntityEvent: return _create!(Tag.blockShearEntityEvent)(this._get!(Tag.blockShearEntityEvent).witClone); break; + case Tag.blockSpreadEvent: return _create!(Tag.blockSpreadEvent)(this._get!(Tag.blockSpreadEvent).witClone); break; + case Tag.brewingStartEvent: return _create!(Tag.brewingStartEvent)(this._get!(Tag.brewingStartEvent).witClone); break; + case Tag.campfireStartEvent: return _create!(Tag.campfireStartEvent)(this._get!(Tag.campfireStartEvent).witClone); break; + case Tag.cauldronLevelChangeEvent: return _create!(Tag.cauldronLevelChangeEvent)(this._get!(Tag.cauldronLevelChangeEvent).witClone); break; + case Tag.crafterCraftEvent: return _create!(Tag.crafterCraftEvent)(this._get!(Tag.crafterCraftEvent).witClone); break; + case Tag.entityBlockFormEvent: return _create!(Tag.entityBlockFormEvent)(this._get!(Tag.entityBlockFormEvent).witClone); break; + case Tag.fluidLevelChangeEvent: return _create!(Tag.fluidLevelChangeEvent)(this._get!(Tag.fluidLevelChangeEvent).witClone); break; + case Tag.inventoryBlockStartEvent: return _create!(Tag.inventoryBlockStartEvent)(this._get!(Tag.inventoryBlockStartEvent).witClone); break; + case Tag.leavesDecayEvent: return _create!(Tag.leavesDecayEvent)(this._get!(Tag.leavesDecayEvent).witClone); break; + case Tag.moistureChangeEvent: return _create!(Tag.moistureChangeEvent)(this._get!(Tag.moistureChangeEvent).witClone); break; + case Tag.sculkBloomEvent: return _create!(Tag.sculkBloomEvent)(this._get!(Tag.sculkBloomEvent).witClone); break; + case Tag.vaultDisplayItemEvent: return _create!(Tag.vaultDisplayItemEvent)(this._get!(Tag.vaultDisplayItemEvent).witClone); break; + case Tag.creatureSpawnEvent: return _create!(Tag.creatureSpawnEvent)(this._get!(Tag.creatureSpawnEvent).witClone); break; + case Tag.enderDragonChangePhaseEvent: return _create!(Tag.enderDragonChangePhaseEvent)(this._get!(Tag.enderDragonChangePhaseEvent).witClone); break; + case Tag.entityBreakDoorEvent: return _create!(Tag.entityBreakDoorEvent)(this._get!(Tag.entityBreakDoorEvent).witClone); break; + case Tag.entityChangeBlockEvent: return _create!(Tag.entityChangeBlockEvent)(this._get!(Tag.entityChangeBlockEvent).witClone); break; + case Tag.entityDamageByBlockEvent: return _create!(Tag.entityDamageByBlockEvent)(this._get!(Tag.entityDamageByBlockEvent).witClone); break; + case Tag.entityDamageByEntityEvent: return _create!(Tag.entityDamageByEntityEvent)(this._get!(Tag.entityDamageByEntityEvent).witClone); break; + case Tag.entityDropItemEvent: return _create!(Tag.entityDropItemEvent)(this._get!(Tag.entityDropItemEvent).witClone); break; + case Tag.entityEnterBlockEvent: return _create!(Tag.entityEnterBlockEvent)(this._get!(Tag.entityEnterBlockEvent).witClone); break; + case Tag.entityExhaustionEvent: return _create!(Tag.entityExhaustionEvent)(this._get!(Tag.entityExhaustionEvent).witClone); break; + case Tag.entityInteractEvent: return _create!(Tag.entityInteractEvent)(this._get!(Tag.entityInteractEvent).witClone); break; + case Tag.entityKnockbackEvent: return _create!(Tag.entityKnockbackEvent)(this._get!(Tag.entityKnockbackEvent).witClone); break; + case Tag.entityPlaceEvent: return _create!(Tag.entityPlaceEvent)(this._get!(Tag.entityPlaceEvent).witClone); break; + case Tag.entityPoseChangeEvent: return _create!(Tag.entityPoseChangeEvent)(this._get!(Tag.entityPoseChangeEvent).witClone); break; + case Tag.entityPotionEffectEvent: return _create!(Tag.entityPotionEffectEvent)(this._get!(Tag.entityPotionEffectEvent).witClone); break; + case Tag.entitySpellCastEvent: return _create!(Tag.entitySpellCastEvent)(this._get!(Tag.entitySpellCastEvent).witClone); break; + case Tag.entityTargetLivingEntityEvent: return _create!(Tag.entityTargetLivingEntityEvent)(this._get!(Tag.entityTargetLivingEntityEvent).witClone); break; + case Tag.entityToggleSwimEvent: return _create!(Tag.entityToggleSwimEvent)(this._get!(Tag.entityToggleSwimEvent).witClone); break; + case Tag.explosionPrimeEvent: return _create!(Tag.explosionPrimeEvent)(this._get!(Tag.explosionPrimeEvent).witClone); break; + case Tag.fireworkExplodeEvent: return _create!(Tag.fireworkExplodeEvent)(this._get!(Tag.fireworkExplodeEvent).witClone); break; + case Tag.foodLevelChangeEvent: return _create!(Tag.foodLevelChangeEvent)(this._get!(Tag.foodLevelChangeEvent).witClone); break; + case Tag.itemDespawnEvent: return _create!(Tag.itemDespawnEvent)(this._get!(Tag.itemDespawnEvent).witClone); break; + case Tag.itemMergeEvent: return _create!(Tag.itemMergeEvent)(this._get!(Tag.itemMergeEvent).witClone); break; + case Tag.itemSpawnEvent: return _create!(Tag.itemSpawnEvent)(this._get!(Tag.itemSpawnEvent).witClone); break; + case Tag.piglinBarterEvent: return _create!(Tag.piglinBarterEvent)(this._get!(Tag.piglinBarterEvent).witClone); break; + case Tag.projectileHitEvent: return _create!(Tag.projectileHitEvent)(this._get!(Tag.projectileHitEvent).witClone); break; + case Tag.projectileLaunchEvent: return _create!(Tag.projectileLaunchEvent)(this._get!(Tag.projectileLaunchEvent).witClone); break; + case Tag.sheepDyeWoolEvent: return _create!(Tag.sheepDyeWoolEvent)(this._get!(Tag.sheepDyeWoolEvent).witClone); break; + case Tag.sheepRegrowWoolEvent: return _create!(Tag.sheepRegrowWoolEvent)(this._get!(Tag.sheepRegrowWoolEvent).witClone); break; + case Tag.slimeSplitEvent: return _create!(Tag.slimeSplitEvent)(this._get!(Tag.slimeSplitEvent).witClone); break; + case Tag.striderTemperatureChangeEvent: return _create!(Tag.striderTemperatureChangeEvent)(this._get!(Tag.striderTemperatureChangeEvent).witClone); break; + case Tag.villagerAcquireTradeEvent: return _create!(Tag.villagerAcquireTradeEvent)(this._get!(Tag.villagerAcquireTradeEvent).witClone); break; + case Tag.villagerCareerChangeEvent: return _create!(Tag.villagerCareerChangeEvent)(this._get!(Tag.villagerCareerChangeEvent).witClone); break; + case Tag.villagerReplenishTradeEvent: return _create!(Tag.villagerReplenishTradeEvent)(this._get!(Tag.villagerReplenishTradeEvent).witClone); break; + case Tag.wardenAngerChangeEvent: return _create!(Tag.wardenAngerChangeEvent)(this._get!(Tag.wardenAngerChangeEvent).witClone); break; + case Tag.areaEffectCloudApplyEvent: return _create!(Tag.areaEffectCloudApplyEvent)(this._get!(Tag.areaEffectCloudApplyEvent).witClone); break; + case Tag.arrowBodyCountChangeEvent: return _create!(Tag.arrowBodyCountChangeEvent)(this._get!(Tag.arrowBodyCountChangeEvent).witClone); break; + case Tag.batToggleSleepEvent: return _create!(Tag.batToggleSleepEvent)(this._get!(Tag.batToggleSleepEvent).witClone); break; + case Tag.creeperPowerEvent: return _create!(Tag.creeperPowerEvent)(this._get!(Tag.creeperPowerEvent).witClone); break; + case Tag.entityCombustByBlockEvent: return _create!(Tag.entityCombustByBlockEvent)(this._get!(Tag.entityCombustByBlockEvent).witClone); break; + case Tag.entityCombustByEntityEvent: return _create!(Tag.entityCombustByEntityEvent)(this._get!(Tag.entityCombustByEntityEvent).witClone); break; + case Tag.entityKnockbackByEntityEvent: return _create!(Tag.entityKnockbackByEntityEvent)(this._get!(Tag.entityKnockbackByEntityEvent).witClone); break; + case Tag.entityPortalEnterEvent: return _create!(Tag.entityPortalEnterEvent)(this._get!(Tag.entityPortalEnterEvent).witClone); break; + case Tag.entityPortalExitEvent: return _create!(Tag.entityPortalExitEvent)(this._get!(Tag.entityPortalExitEvent).witClone); break; + case Tag.entityRemoveEvent: return _create!(Tag.entityRemoveEvent)(this._get!(Tag.entityRemoveEvent).witClone); break; + case Tag.entityTargetBlockEvent: return _create!(Tag.entityTargetBlockEvent)(this._get!(Tag.entityTargetBlockEvent).witClone); break; + case Tag.entityUnleashEvent: return _create!(Tag.entityUnleashEvent)(this._get!(Tag.entityUnleashEvent).witClone); break; + case Tag.expBottleEvent: return _create!(Tag.expBottleEvent)(this._get!(Tag.expBottleEvent).witClone); break; + case Tag.horseJumpEvent: return _create!(Tag.horseJumpEvent)(this._get!(Tag.horseJumpEvent).witClone); break; + case Tag.lingeringPotionSplashEvent: return _create!(Tag.lingeringPotionSplashEvent)(this._get!(Tag.lingeringPotionSplashEvent).witClone); break; + case Tag.pigZapEvent: return _create!(Tag.pigZapEvent)(this._get!(Tag.pigZapEvent).witClone); break; + case Tag.pigZombieAngerEvent: return _create!(Tag.pigZombieAngerEvent)(this._get!(Tag.pigZombieAngerEvent).witClone); break; + case Tag.potionSplashEvent: return _create!(Tag.potionSplashEvent)(this._get!(Tag.potionSplashEvent).witClone); break; + case Tag.spawnerSpawnEvent: return _create!(Tag.spawnerSpawnEvent)(this._get!(Tag.spawnerSpawnEvent).witClone); break; + case Tag.trialSpawnerSpawnEvent: return _create!(Tag.trialSpawnerSpawnEvent)(this._get!(Tag.trialSpawnerSpawnEvent).witClone); break; + case Tag.villagerReputationChangeEvent: return _create!(Tag.villagerReputationChangeEvent)(this._get!(Tag.villagerReputationChangeEvent).witClone); break; + case Tag.asyncPlayerChatEvent: return _create!(Tag.asyncPlayerChatEvent)(this._get!(Tag.asyncPlayerChatEvent).witClone); break; + case Tag.asyncPlayerPreLoginEvent: return _create!(Tag.asyncPlayerPreLoginEvent)(this._get!(Tag.asyncPlayerPreLoginEvent).witClone); break; + case Tag.playerAdvancementDoneEvent: return _create!(Tag.playerAdvancementDoneEvent)(this._get!(Tag.playerAdvancementDoneEvent).witClone); break; + case Tag.playerAnimationEvent: return _create!(Tag.playerAnimationEvent)(this._get!(Tag.playerAnimationEvent).witClone); break; + case Tag.playerArmorStandManipulateEvent: return _create!(Tag.playerArmorStandManipulateEvent)(this._get!(Tag.playerArmorStandManipulateEvent).witClone); break; + case Tag.playerBucketEntityEvent: return _create!(Tag.playerBucketEntityEvent)(this._get!(Tag.playerBucketEntityEvent).witClone); break; + case Tag.playerChangedWorldEvent: return _create!(Tag.playerChangedWorldEvent)(this._get!(Tag.playerChangedWorldEvent).witClone); break; + case Tag.playerChannelEvent: return _create!(Tag.playerChannelEvent)(this._get!(Tag.playerChannelEvent).witClone); break; + case Tag.playerCommandPreprocessEvent: return _create!(Tag.playerCommandPreprocessEvent)(this._get!(Tag.playerCommandPreprocessEvent).witClone); break; + case Tag.playerEditBookEvent: return _create!(Tag.playerEditBookEvent)(this._get!(Tag.playerEditBookEvent).witClone); break; + case Tag.playerElytraBoostEvent: return _create!(Tag.playerElytraBoostEvent)(this._get!(Tag.playerElytraBoostEvent).witClone); break; + case Tag.playerExpCooldownChangeEvent: return _create!(Tag.playerExpCooldownChangeEvent)(this._get!(Tag.playerExpCooldownChangeEvent).witClone); break; + case Tag.playerHarvestBlockEvent: return _create!(Tag.playerHarvestBlockEvent)(this._get!(Tag.playerHarvestBlockEvent).witClone); break; + case Tag.playerHideEntityEvent: return _create!(Tag.playerHideEntityEvent)(this._get!(Tag.playerHideEntityEvent).witClone); break; + case Tag.playerItemBreakEvent: return _create!(Tag.playerItemBreakEvent)(this._get!(Tag.playerItemBreakEvent).witClone); break; + case Tag.playerItemMendEvent: return _create!(Tag.playerItemMendEvent)(this._get!(Tag.playerItemMendEvent).witClone); break; + case Tag.playerKickEvent: return _create!(Tag.playerKickEvent)(this._get!(Tag.playerKickEvent).witClone); break; + case Tag.playerLeashEntityEvent: return _create!(Tag.playerLeashEntityEvent)(this._get!(Tag.playerLeashEntityEvent).witClone); break; + case Tag.playerLevelChangeEvent: return _create!(Tag.playerLevelChangeEvent)(this._get!(Tag.playerLevelChangeEvent).witClone); break; + case Tag.playerLocaleChangeEvent: return _create!(Tag.playerLocaleChangeEvent)(this._get!(Tag.playerLocaleChangeEvent).witClone); break; + case Tag.playerNameEntityEvent: return _create!(Tag.playerNameEntityEvent)(this._get!(Tag.playerNameEntityEvent).witClone); break; + case Tag.playerOpenSignEvent: return _create!(Tag.playerOpenSignEvent)(this._get!(Tag.playerOpenSignEvent).witClone); break; + case Tag.playerPortalEvent: return _create!(Tag.playerPortalEvent)(this._get!(Tag.playerPortalEvent).witClone); break; + case Tag.playerPreLoginEvent: return _create!(Tag.playerPreLoginEvent)(this._get!(Tag.playerPreLoginEvent).witClone); break; + case Tag.playerRiptideEvent: return _create!(Tag.playerRiptideEvent)(this._get!(Tag.playerRiptideEvent).witClone); break; + case Tag.playerShearEntityEvent: return _create!(Tag.playerShearEntityEvent)(this._get!(Tag.playerShearEntityEvent).witClone); break; + case Tag.playerShowEntityEvent: return _create!(Tag.playerShowEntityEvent)(this._get!(Tag.playerShowEntityEvent).witClone); break; + case Tag.playerSpawnChangeEvent: return _create!(Tag.playerSpawnChangeEvent)(this._get!(Tag.playerSpawnChangeEvent).witClone); break; + case Tag.playerStatisticIncrementEvent: return _create!(Tag.playerStatisticIncrementEvent)(this._get!(Tag.playerStatisticIncrementEvent).witClone); break; + case Tag.playerSwapHandsEvent: return _create!(Tag.playerSwapHandsEvent)(this._get!(Tag.playerSwapHandsEvent).witClone); break; + case Tag.playerTakeLecternBookEvent: return _create!(Tag.playerTakeLecternBookEvent)(this._get!(Tag.playerTakeLecternBookEvent).witClone); break; + case Tag.playerUnleashEntityEvent: return _create!(Tag.playerUnleashEntityEvent)(this._get!(Tag.playerUnleashEntityEvent).witClone); break; + case Tag.playerVelocityEvent: return _create!(Tag.playerVelocityEvent)(this._get!(Tag.playerVelocityEvent).witClone); break; + case Tag.playerInputEvent: return _create!(Tag.playerInputEvent)(this._get!(Tag.playerInputEvent).witClone); break; + case Tag.playerInteractAtEntityEvent: return _create!(Tag.playerInteractAtEntityEvent)(this._get!(Tag.playerInteractAtEntityEvent).witClone); break; + case Tag.playerLinksSendEvent: return _create!(Tag.playerLinksSendEvent)(this._get!(Tag.playerLinksSendEvent).witClone); break; + case Tag.playerPickupArrowEvent: return _create!(Tag.playerPickupArrowEvent)(this._get!(Tag.playerPickupArrowEvent).witClone); break; + case Tag.playerRecipeBookClickEvent: return _create!(Tag.playerRecipeBookClickEvent)(this._get!(Tag.playerRecipeBookClickEvent).witClone); break; + case Tag.playerRecipeBookSettingsChangeEvent: return _create!(Tag.playerRecipeBookSettingsChangeEvent)(this._get!(Tag.playerRecipeBookSettingsChangeEvent).witClone); break; + case Tag.playerRecipeDiscoverEvent: return _create!(Tag.playerRecipeDiscoverEvent)(this._get!(Tag.playerRecipeDiscoverEvent).witClone); break; + case Tag.playerRegisterChannelEvent: return _create!(Tag.playerRegisterChannelEvent)(this._get!(Tag.playerRegisterChannelEvent).witClone); break; + case Tag.playerResourcePackStatusEvent: return _create!(Tag.playerResourcePackStatusEvent)(this._get!(Tag.playerResourcePackStatusEvent).witClone); break; + case Tag.playerSpawnLocationEvent: return _create!(Tag.playerSpawnLocationEvent)(this._get!(Tag.playerSpawnLocationEvent).witClone); break; + case Tag.playerUnregisterChannelEvent: return _create!(Tag.playerUnregisterChannelEvent)(this._get!(Tag.playerUnregisterChannelEvent).witClone); break; + case Tag.raidFinishEvent: return _create!(Tag.raidFinishEvent)(this._get!(Tag.raidFinishEvent).witClone); break; + case Tag.raidSpawnWaveEvent: return _create!(Tag.raidSpawnWaveEvent)(this._get!(Tag.raidSpawnWaveEvent).witClone); break; + case Tag.raidStopEvent: return _create!(Tag.raidStopEvent)(this._get!(Tag.raidStopEvent).witClone); break; + case Tag.raidTriggerEvent: return _create!(Tag.raidTriggerEvent)(this._get!(Tag.raidTriggerEvent).witClone); break; + case Tag.lightningStrikeEvent: return _create!(Tag.lightningStrikeEvent)(this._get!(Tag.lightningStrikeEvent).witClone); break; + } + } +} diff --git a/src/wit/pumpkin/plugin/forms/common.d b/src/wit/pumpkin/plugin/forms/common.d new file mode 100644 index 0000000..d3a7938 --- /dev/null +++ b/src/wit/pumpkin/plugin/forms/common.d @@ -0,0 +1,54 @@ +/++ + ++/ +module wit.pumpkin.plugin.forms.common; + + +import wit.common; + +static import wit.pumpkin.plugin.text.common; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +enum ImageType : ubyte { + /++ + + +/ + url, + + /++ + + +/ + path, +} +/++ + ++/ +struct FormImage { + /++ + + +/ + ImageType type; + + /++ + + +/ + WitString data; + + void witFree() @nogc nothrow { + data.witFree; + } + + void witDrop() @nogc nothrow { + } + + FormImage witClone() const @nogc nothrow { + FormImage clone = void; + clone.type = this.type.witClone; + clone.data = this.data.witClone; + return clone; + } +} diff --git a/src/wit/pumpkin/plugin/forms/imports.d b/src/wit/pumpkin/plugin/forms/imports.d new file mode 100644 index 0000000..93c2c98 --- /dev/null +++ b/src/wit/pumpkin/plugin/forms/imports.d @@ -0,0 +1,377 @@ +/++ + ++/ +module wit.pumpkin.plugin.forms.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.forms.common; + +static import wit.pumpkin.plugin.text.imports; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias TextComponent = wit.pumpkin.plugin.text.imports.TextComponent; + +/++ + ++/ +struct SimpleFormButton { + /++ + + +/ + TextComponent text; + + /++ + + +/ + Option!(FormImage) image; + + void witFree() @nogc nothrow { + image.witFree; + } + + void witDrop() @nogc nothrow { + text.witDrop; + } + + SimpleFormButton witClone() const @nogc nothrow { + SimpleFormButton clone = void; + clone.text = this.text.witClone; + clone.image = this.image.witClone; + return clone; + } +} + +/++ + ++/ +struct SimpleForm { + /++ + + +/ + TextComponent title; + + /++ + + +/ + TextComponent content; + + /++ + + +/ + WitList!(SimpleFormButton) buttons; + + void witFree() @nogc nothrow { + buttons.witFree; + } + + void witDrop() @nogc nothrow { + title.witDrop; + content.witDrop; + buttons.witDrop; + } + + SimpleForm witClone() const @nogc nothrow { + SimpleForm clone = void; + clone.title = this.title.witClone; + clone.content = this.content.witClone; + clone.buttons = this.buttons.witClone; + return clone; + } +} + +/++ + ++/ +struct ModalForm { + /++ + + +/ + TextComponent title; + + /++ + + +/ + TextComponent content; + + /++ + + +/ + TextComponent button1; + + /++ + + +/ + TextComponent button2; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + title.witDrop; + content.witDrop; + button1.witDrop; + button2.witDrop; + } + + ModalForm witClone() const @nogc nothrow { + ModalForm clone = void; + clone.title = this.title.witClone; + clone.content = this.content.witClone; + clone.button1 = this.button1.witClone; + clone.button2 = this.button2.witClone; + return clone; + } +} + +/++ + ++/ +struct CustomFormElement { + mixin WitVariant!( + TextComponent, // label + Tuple!(TextComponent, bool), // toggle + Tuple!(TextComponent, float, float, float, float), // slider + Tuple!(TextComponent, WitList!(WitString), uint), // stepSlider + Tuple!(TextComponent, WitList!(WitString), uint), // dropdown + Tuple!(TextComponent, WitString, WitString), // input + ); + +public: + enum Tag : ubyte { + /++ + + +/ + label, + + /++ + + +/ + toggle, + + /++ + + +/ + slider, + + /++ + text, min, max, step, default + +/ + stepSlider, + + /++ + text, steps, default + +/ + dropdown, + + /++ + text, options, default + +/ + input, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias label = _create!(Tag.label); + /// ditto + pragma(inline, true) bool isLabel() const => _tag == Tag.label; + ///ditto + alias getLabel = _get!(Tag.label); + + /++ + + +/ + alias toggle = _create!(Tag.toggle); + /// ditto + pragma(inline, true) bool isToggle() const => _tag == Tag.toggle; + ///ditto + alias getToggle = _get!(Tag.toggle); + + /++ + + +/ + alias slider = _create!(Tag.slider); + /// ditto + pragma(inline, true) bool isSlider() const => _tag == Tag.slider; + ///ditto + alias getSlider = _get!(Tag.slider); + + /++ + text, min, max, step, default + +/ + alias stepSlider = _create!(Tag.stepSlider); + /// ditto + pragma(inline, true) bool isStepSlider() const => _tag == Tag.stepSlider; + ///ditto + alias getStepSlider = _get!(Tag.stepSlider); + + /++ + text, steps, default + +/ + alias dropdown = _create!(Tag.dropdown); + /// ditto + pragma(inline, true) bool isDropdown() const => _tag == Tag.dropdown; + ///ditto + alias getDropdown = _get!(Tag.dropdown); + + /++ + text, options, default + +/ + alias input = _create!(Tag.input); + /// ditto + pragma(inline, true) bool isInput() const => _tag == Tag.input; + ///ditto + alias getInput = _get!(Tag.input); + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case stepSlider: _get!(Tag.stepSlider).witFree; break; + case dropdown: _get!(Tag.dropdown).witFree; break; + case input: _get!(Tag.input).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + switch (_tag) with (Tag) { + case label: _get!(Tag.label).witDrop; break; + case toggle: _get!(Tag.toggle).witDrop; break; + case slider: _get!(Tag.slider).witDrop; break; + case stepSlider: _get!(Tag.stepSlider).witDrop; break; + case dropdown: _get!(Tag.dropdown).witDrop; break; + case input: _get!(Tag.input).witDrop; break; + default: break; + } + } + + CustomFormElement witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.label: return _create!(Tag.label)(this._get!(Tag.label).witClone); break; + case Tag.toggle: return _create!(Tag.toggle)(this._get!(Tag.toggle).witClone); break; + case Tag.slider: return _create!(Tag.slider)(this._get!(Tag.slider).witClone); break; + case Tag.stepSlider: return _create!(Tag.stepSlider)(this._get!(Tag.stepSlider).witClone); break; + case Tag.dropdown: return _create!(Tag.dropdown)(this._get!(Tag.dropdown).witClone); break; + case Tag.input: return _create!(Tag.input)(this._get!(Tag.input).witClone); break; + } + } +} + +/++ + ++/ +struct CustomForm { + /++ + + +/ + TextComponent title; + + /++ + + +/ + WitList!(CustomFormElement) elements; + + void witFree() @nogc nothrow { + elements.witFree; + } + + void witDrop() @nogc nothrow { + title.witDrop; + elements.witDrop; + } + + CustomForm witClone() const @nogc nothrow { + CustomForm clone = void; + clone.title = this.title.witClone; + clone.elements = this.elements.witClone; + return clone; + } +} + +/++ + ++/ +struct Form { + mixin WitVariant!( + SimpleForm, // simple + ModalForm, // modal + CustomForm, // custom + ); + +public: + enum Tag : ubyte { + /++ + + +/ + simple, + + /++ + + +/ + modal, + + /++ + + +/ + custom, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias simple = _create!(Tag.simple); + /// ditto + pragma(inline, true) bool isSimple() const => _tag == Tag.simple; + ///ditto + alias getSimple = _get!(Tag.simple); + + /++ + + +/ + alias modal = _create!(Tag.modal); + /// ditto + pragma(inline, true) bool isModal() const => _tag == Tag.modal; + ///ditto + alias getModal = _get!(Tag.modal); + + /++ + + +/ + alias custom = _create!(Tag.custom); + /// ditto + pragma(inline, true) bool isCustom() const => _tag == Tag.custom; + ///ditto + alias getCustom = _get!(Tag.custom); + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case simple: _get!(Tag.simple).witFree; break; + case custom: _get!(Tag.custom).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + switch (_tag) with (Tag) { + case simple: _get!(Tag.simple).witDrop; break; + case modal: _get!(Tag.modal).witDrop; break; + case custom: _get!(Tag.custom).witDrop; break; + default: break; + } + } + + Form witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.simple: return _create!(Tag.simple)(this._get!(Tag.simple).witClone); break; + case Tag.modal: return _create!(Tag.modal)(this._get!(Tag.modal).witClone); break; + case Tag.custom: return _create!(Tag.custom)(this._get!(Tag.custom).witClone); break; + } + } +} diff --git a/src/wit/pumpkin/plugin/game_events/common.d b/src/wit/pumpkin/plugin/game_events/common.d new file mode 100644 index 0000000..f3182e4 --- /dev/null +++ b/src/wit/pumpkin/plugin/game_events/common.d @@ -0,0 +1,320 @@ +/++ + ++/ +module wit.pumpkin.plugin.game_events.common; + + +import wit.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +enum GameEvent : ubyte { + /++ + + +/ + blockActivate, + + /++ + + +/ + blockAttach, + + /++ + + +/ + blockChange, + + /++ + + +/ + blockClose, + + /++ + + +/ + blockDeactivate, + + /++ + + +/ + blockDestroy, + + /++ + + +/ + blockDetach, + + /++ + + +/ + blockOpen, + + /++ + + +/ + blockPlace, + + /++ + + +/ + bounce, + + /++ + + +/ + containerClose, + + /++ + + +/ + containerOpen, + + /++ + + +/ + drink, + + /++ + + +/ + eat, + + /++ + + +/ + elytraGlide, + + /++ + + +/ + entityDamage, + + /++ + + +/ + entityDie, + + /++ + + +/ + entityDismount, + + /++ + + +/ + entityInteract, + + /++ + + +/ + entityMount, + + /++ + + +/ + entityPlace, + + /++ + + +/ + entityAction, + + /++ + + +/ + equip, + + /++ + + +/ + explode, + + /++ + + +/ + flap, + + /++ + + +/ + fluidPickup, + + /++ + + +/ + fluidPlace, + + /++ + + +/ + hitGround, + + /++ + + +/ + instrumentPlay, + + /++ + + +/ + itemInteractFinish, + + /++ + + +/ + itemInteractStart, + + /++ + + +/ + jukeboxPlay, + + /++ + + +/ + jukeboxStopPlay, + + /++ + + +/ + lightningStrike, + + /++ + + +/ + noteBlockPlay, + + /++ + + +/ + primeFuse, + + /++ + + +/ + projectileLand, + + /++ + + +/ + projectileShoot, + + /++ + + +/ + sculkSensorTendrilsClicking, + + /++ + + +/ + shear, + + /++ + + +/ + shriek, + + /++ + + +/ + splash, + + /++ + + +/ + step, + + /++ + + +/ + swim, + + /++ + + +/ + teleport, + + /++ + + +/ + unequip, + + /++ + + +/ + resonate1, + + /++ + + +/ + resonate2, + + /++ + + +/ + resonate3, + + /++ + + +/ + resonate4, + + /++ + + +/ + resonate5, + + /++ + + +/ + resonate6, + + /++ + + +/ + resonate7, + + /++ + + +/ + resonate8, + + /++ + + +/ + resonate9, + + /++ + + +/ + resonate10, + + /++ + + +/ + resonate11, + + /++ + + +/ + resonate12, + + /++ + + +/ + resonate13, + + /++ + + +/ + resonate14, + + /++ + + +/ + resonate15, +} \ No newline at end of file diff --git a/src/wit/pumpkin/plugin/game_events/imports.d b/src/wit/pumpkin/plugin/game_events/imports.d new file mode 100644 index 0000000..d2eefae --- /dev/null +++ b/src/wit/pumpkin/plugin/game_events/imports.d @@ -0,0 +1,12 @@ +/++ + ++/ +module wit.pumpkin.plugin.game_events.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.game_events.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); diff --git a/src/wit/pumpkin/plugin/game_rules/common.d b/src/wit/pumpkin/plugin/game_rules/common.d new file mode 100644 index 0000000..6d5f239 --- /dev/null +++ b/src/wit/pumpkin/plugin/game_rules/common.d @@ -0,0 +1,364 @@ +/++ + ++/ +module wit.pumpkin.plugin.game_rules.common; + + +import wit.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +enum GameRule : ubyte { + /++ + + +/ + advanceTime, + + /++ + + +/ + advanceWeather, + + /++ + + +/ + allowEnteringNetherUsingPortals, + + /++ + + +/ + blockDrops, + + /++ + + +/ + blockExplosionDropDecay, + + /++ + + +/ + commandBlockOutput, + + /++ + + +/ + commandBlocksWork, + + /++ + + +/ + drowningDamage, + + /++ + + +/ + elytraMovementCheck, + + /++ + + +/ + enderPearlsVanishOnDeath, + + /++ + + +/ + entityDrops, + + /++ + + +/ + fallDamage, + + /++ + + +/ + fireDamage, + + /++ + + +/ + fireSpreadRadiusAroundPlayer, + + /++ + + +/ + forgiveDeadPlayers, + + /++ + + +/ + freezeDamage, + + /++ + + +/ + globalSoundEvents, + + /++ + + +/ + immediateRespawn, + + /++ + + +/ + keepInventory, + + /++ + + +/ + lavaSourceConversion, + + /++ + + +/ + limitedCrafting, + + /++ + + +/ + locatorBar, + + /++ + + +/ + logAdminCommands, + + /++ + + +/ + maxBlockModifications, + + /++ + + +/ + maxCommandForks, + + /++ + + +/ + maxCommandSequenceLength, + + /++ + + +/ + maxEntityCramming, + + /++ + + +/ + maxMinecartSpeed, + + /++ + + +/ + maxSnowAccumulationHeight, + + /++ + + +/ + mobDrops, + + /++ + + +/ + mobExplosionDropDecay, + + /++ + + +/ + mobGriefing, + + /++ + + +/ + naturalHealthRegeneration, + + /++ + + +/ + playerMovementCheck, + + /++ + + +/ + playersNetherPortalCreativeDelay, + + /++ + + +/ + playersNetherPortalDefaultDelay, + + /++ + + +/ + playersSleepingPercentage, + + /++ + + +/ + projectilesCanBreakBlocks, + + /++ + + +/ + pvp, + + /++ + + +/ + raids, + + /++ + + +/ + randomTickSpeed, + + /++ + + +/ + reducedDebugInfo, + + /++ + + +/ + respawnRadius, + + /++ + + +/ + sendCommandFeedback, + + /++ + + +/ + showAdvancementMessages, + + /++ + + +/ + showDeathMessages, + + /++ + + +/ + spawnMobs, + + /++ + + +/ + spawnMonsters, + + /++ + + +/ + spawnPatrols, + + /++ + + +/ + spawnPhantoms, + + /++ + + +/ + spawnWanderingTraders, + + /++ + + +/ + spawnWardens, + + /++ + + +/ + spawnerBlocksWork, + + /++ + + +/ + spectatorsGenerateChunks, + + /++ + + +/ + spreadVines, + + /++ + + +/ + tntExplodes, + + /++ + + +/ + tntExplosionDropDecay, + + /++ + + +/ + universalAnger, + + /++ + + +/ + waterSourceConversion, +} +/++ + ++/ +struct GameRuleValue { + mixin WitVariant!( + int, // int_ + bool, // bool_ + ); + +public: + enum Tag : ubyte { + /++ + + +/ + int_, + + /++ + + +/ + bool_, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias int_ = _create!(Tag.int_); + /// ditto + pragma(inline, true) bool isInt() const => _tag == Tag.int_; + ///ditto + alias getInt = _get!(Tag.int_); + + /++ + + +/ + alias bool_ = _create!(Tag.bool_); + /// ditto + pragma(inline, true) bool isBool() const => _tag == Tag.bool_; + ///ditto + alias getBool = _get!(Tag.bool_); + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + GameRuleValue witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.int_: return _create!(Tag.int_)(this._get!(Tag.int_).witClone); break; + case Tag.bool_: return _create!(Tag.bool_)(this._get!(Tag.bool_).witClone); break; + } + } +} diff --git a/src/wit/pumpkin/plugin/game_rules/imports.d b/src/wit/pumpkin/plugin/game_rules/imports.d new file mode 100644 index 0000000..bf488a5 --- /dev/null +++ b/src/wit/pumpkin/plugin/game_rules/imports.d @@ -0,0 +1,12 @@ +/++ + ++/ +module wit.pumpkin.plugin.game_rules.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.game_rules.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); diff --git a/src/wit/pumpkin/plugin/gui/common.d b/src/wit/pumpkin/plugin/gui/common.d new file mode 100644 index 0000000..08a27d5 --- /dev/null +++ b/src/wit/pumpkin/plugin/gui/common.d @@ -0,0 +1,25 @@ +/++ + ++/ +module wit.pumpkin.plugin.gui.common; + + +import wit.common; + +static import wit.pumpkin.plugin.common.common; +static import wit.pumpkin.plugin.screens.common; +static import wit.pumpkin.plugin.text.common; +static import wit.pumpkin.plugin.item_stack.common; +static import wit.pumpkin.plugin.inventory.common; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias ClickType = wit.pumpkin.plugin.common.common.ClickType; + +/++ + ++/ +alias Screen = wit.pumpkin.plugin.screens.common.Screen; diff --git a/src/wit/pumpkin/plugin/gui/imports.d b/src/wit/pumpkin/plugin/gui/imports.d new file mode 100644 index 0000000..8912770 --- /dev/null +++ b/src/wit/pumpkin/plugin/gui/imports.d @@ -0,0 +1,229 @@ +/++ + ++/ +module wit.pumpkin.plugin.gui.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.gui.common; + +static import wit.pumpkin.plugin.common.imports; +static import wit.pumpkin.plugin.screens.imports; +static import wit.pumpkin.plugin.text.imports; +static import wit.pumpkin.plugin.item_stack.imports; +static import wit.pumpkin.plugin.inventory.imports; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias TextComponent = wit.pumpkin.plugin.text.imports.TextComponent; + +/++ + ++/ +alias ItemStack = wit.pumpkin.plugin.item_stack.imports.ItemStack; + +/++ + ++/ +alias Inventory = wit.pumpkin.plugin.inventory.imports.Inventory; + +/++ + ++/ +struct Gui { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + /++ + + +/ + static Gui makeNew(Screen type, TextComponent title) @trusted nothrow { + auto _ret = __import_makeNew(cast(uint)(type), title.__handle); + auto _handle0 = Gui(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/gui@0.1.0", "[constructor]gui") + pragma(mangle, "__wit_import_pumpkin:plugin__gui@0.1.0__:constructor:gui") + static private extern(C) uint __import_makeNew(uint, uint) nothrow; + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/gui@0.1.0", "[resource-drop]gui") + pragma(mangle, "__wit_import_pumpkin:plugin__gui@0.1.0__:resource_drop:gui") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + Returns the underlying inventory handle for this GUI. + +/ + Inventory getInventory() @trusted nothrow { + auto _ret = __import_getInventory(this.__handle); + auto _handle0 = Inventory(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/gui@0.1.0", "[method]gui.get-inventory") + pragma(mangle, "__wit_import_pumpkin:plugin__gui@0.1.0__:method:gui.get_inventory") + static private extern(C) uint __import_getInventory(uint) nothrow; + + /++ + + +/ + void setItem(uint slot, ItemStack item) @trusted nothrow { + __import_setItem(this.__handle, slot, item.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/gui@0.1.0", "[method]gui.set-item") + pragma(mangle, "__wit_import_pumpkin:plugin__gui@0.1.0__:method:gui.set_item") + static private extern(C) void __import_setItem(uint, uint, uint) nothrow; + + /++ + + +/ + Option!(ItemStack) getItem(uint slot) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getItem(this.__handle, slot, _retArea.ptr); + Option!(ItemStack) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = ItemStack(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(ItemStack).makeSome(_handle2); + } else { + _option3 = Option!(ItemStack).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/gui@0.1.0", "[method]gui.get-item") + pragma(mangle, "__wit_import_pumpkin:plugin__gui@0.1.0__:method:gui.get_item") + static private extern(C) void __import_getItem(uint, uint, void*) nothrow; + + /++ + Returns the type of this GUI. + +/ + Screen getType() @trusted nothrow { + auto _ret = __import_getType(this.__handle); + return cast(wit.pumpkin.plugin.screens.imports.Screen)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/gui@0.1.0", "[method]gui.get-type") + pragma(mangle, "__wit_import_pumpkin:plugin__gui@0.1.0__:method:gui.get_type") + static private extern(C) uint __import_getType(uint) nothrow; + + /++ + Returns the title of this GUI. + +/ + TextComponent getTitle() @trusted nothrow { + auto _ret = __import_getTitle(this.__handle); + auto _handle0 = TextComponent(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/gui@0.1.0", "[method]gui.get-title") + pragma(mangle, "__wit_import_pumpkin:plugin__gui@0.1.0__:method:gui.get_title") + static private extern(C) uint __import_getTitle(uint) nothrow; + + /++ + Returns the number of slots in this GUI. + +/ + uint getSize() @trusted nothrow { + auto _ret = __import_getSize(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/gui@0.1.0", "[method]gui.get-size") + pragma(mangle, "__wit_import_pumpkin:plugin__gui@0.1.0__:method:gui.get_size") + static private extern(C) uint __import_getSize(uint) nothrow; + + /++ + Clears all items from the GUI. + +/ + void clearItems() @trusted nothrow { + __import_clearItems(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/gui@0.1.0", "[method]gui.clear-items") + pragma(mangle, "__wit_import_pumpkin:plugin__gui@0.1.0__:method:gui.clear_items") + static private extern(C) void __import_clearItems(uint) nothrow; + + /++ + Sets whether players can grab items out of the inventory. + +/ + void setAllowGrabItems(bool allow) @trusted nothrow { + __import_setAllowGrabItems(this.__handle, cast(uint)(allow)); + } + /// ditto + @wasmImport!("pumpkin:plugin/gui@0.1.0", "[method]gui.set-allow-grab-items") + pragma(mangle, "__wit_import_pumpkin:plugin__gui@0.1.0__:method:gui.set_allow_grab_items") + static private extern(C) void __import_setAllowGrabItems(uint, uint) nothrow; + + /++ + Returns whether players can grab items out of the inventory. + +/ + bool getAllowGrabItems() @trusted nothrow { + auto _ret = __import_getAllowGrabItems(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/gui@0.1.0", "[method]gui.get-allow-grab-items") + pragma(mangle, "__wit_import_pumpkin:plugin__gui@0.1.0__:method:gui.get_allow_grab_items") + static private extern(C) uint __import_getAllowGrabItems(uint) nothrow; + + /++ + Sets whether players can put items into the inventory from their own. + +/ + void setAllowPutItems(bool allow) @trusted nothrow { + __import_setAllowPutItems(this.__handle, cast(uint)(allow)); + } + /// ditto + @wasmImport!("pumpkin:plugin/gui@0.1.0", "[method]gui.set-allow-put-items") + pragma(mangle, "__wit_import_pumpkin:plugin__gui@0.1.0__:method:gui.set_allow_put_items") + static private extern(C) void __import_setAllowPutItems(uint, uint) nothrow; + + /++ + Returns whether players can put items into the inventory from their own. + +/ + bool getAllowPutItems() @trusted nothrow { + auto _ret = __import_getAllowPutItems(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/gui@0.1.0", "[method]gui.get-allow-put-items") + pragma(mangle, "__wit_import_pumpkin:plugin__gui@0.1.0__:method:gui.get_allow_put_items") + static private extern(C) uint __import_getAllowPutItems(uint) nothrow; + } +} diff --git a/src/wit/pumpkin/plugin/i18n/common.d b/src/wit/pumpkin/plugin/i18n/common.d new file mode 100644 index 0000000..d99d7bd --- /dev/null +++ b/src/wit/pumpkin/plugin/i18n/common.d @@ -0,0 +1,16 @@ +/++ + ++/ +module wit.pumpkin.plugin.i18n.common; + + +import wit.common; + +static import wit.pumpkin.plugin.common.common; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias Locale = wit.pumpkin.plugin.common.common.Locale; diff --git a/src/wit/pumpkin/plugin/i18n/imports.d b/src/wit/pumpkin/plugin/i18n/imports.d new file mode 100644 index 0000000..99fba4c --- /dev/null +++ b/src/wit/pumpkin/plugin/i18n/imports.d @@ -0,0 +1,53 @@ +/++ + ++/ +module wit.pumpkin.plugin.i18n.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.i18n.common; + +static import wit.pumpkin.plugin.common.imports; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ +Retrieves a translated string from the host. + +# Arguments +* `key`: The namespaced translation key (e.g. `pumpkin:my_key`). +* `locale`: The target locale. + +# Returns +The localized string, falling back to English or the key itself. ++/ +WitString translate(in WitString key, Locale locale) @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_translate(cast(void*)(key.ptr), key.length, cast(uint)(locale), _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; +} +/// ditto +@wasmImport!("pumpkin:plugin/i18n@0.1.0", "translate") +pragma(mangle, "__wit_import_pumpkin:plugin__i18n@0.1.0__translate") +private extern(C) void __import_translate(void*, size_t, uint, void*) nothrow; + +/++ +Loads custom translations from a JSON string. + +# Arguments +* `namespace`: The namespace to associate these keys with. +* `json`: A JSON string containing a flat map of translations. +* `locale`: The target locale for these translations. ++/ +void loadTranslations(in WitString namespace, in WitString json, Locale locale) @trusted nothrow { + __import_loadTranslations(cast(void*)(namespace.ptr), namespace.length, cast(void*)(json.ptr), json.length, cast(uint)(locale)); +} +/// ditto +@wasmImport!("pumpkin:plugin/i18n@0.1.0", "load-translations") +pragma(mangle, "__wit_import_pumpkin:plugin__i18n@0.1.0__load_translations") +private extern(C) void __import_loadTranslations(void*, size_t, void*, size_t, uint) nothrow; diff --git a/src/wit/pumpkin/plugin/inventory/common.d b/src/wit/pumpkin/plugin/inventory/common.d new file mode 100644 index 0000000..ea17d11 --- /dev/null +++ b/src/wit/pumpkin/plugin/inventory/common.d @@ -0,0 +1,17 @@ +/++ + ++/ +module wit.pumpkin.plugin.inventory.common; + + +import wit.common; + +static import wit.pumpkin.plugin.common.common; +static import wit.pumpkin.plugin.item_stack.common; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias Hand = wit.pumpkin.plugin.common.common.Hand; diff --git a/src/wit/pumpkin/plugin/inventory/imports.d b/src/wit/pumpkin/plugin/inventory/imports.d new file mode 100644 index 0000000..a63cc2d --- /dev/null +++ b/src/wit/pumpkin/plugin/inventory/imports.d @@ -0,0 +1,625 @@ +/++ + ++/ +module wit.pumpkin.plugin.inventory.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.inventory.common; + +static import wit.pumpkin.plugin.common.imports; +static import wit.pumpkin.plugin.item_stack.imports; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias ItemStack = wit.pumpkin.plugin.item_stack.imports.ItemStack; + +/++ +Common inventory resource used across GUIs, player inventories, and containers. ++/ +struct Inventory { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[resource-drop]inventory") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:resource_drop:inventory") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + Returns the number of slots in this inventory. + +/ + uint getSize() @trusted nothrow { + auto _ret = __import_getSize(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]inventory.get-size") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:inventory.get_size") + static private extern(C) uint __import_getSize(uint) nothrow; + + /++ + Returns true if all slots in this inventory are empty. + +/ + bool isEmpty() @trusted nothrow { + auto _ret = __import_isEmpty(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]inventory.is-empty") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:inventory.is_empty") + static private extern(C) uint __import_isEmpty(uint) nothrow; + + /++ + Returns the item in the specified slot index, or none if empty. + +/ + Option!(ItemStack) getItem(uint slot) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getItem(this.__handle, slot, _retArea.ptr); + Option!(ItemStack) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = ItemStack(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(ItemStack).makeSome(_handle2); + } else { + _option3 = Option!(ItemStack).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]inventory.get-item") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:inventory.get_item") + static private extern(C) void __import_getItem(uint, uint, void*) nothrow; + + /++ + Sets the item in the specified slot index. + +/ + void setItem(uint slot, in Option!(ItemStack) item) @trusted nothrow { + uint _option4 = void; + uint _option5 = void; + if (item.isSome) { + ref _payload3 = item.unwrap(); + _option4 = 1; + _option5 = _payload3.__handle; + } else { + _option4 = 0; + _option5 = 0; + } + __import_setItem(this.__handle, slot, _option4, _option5); + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]inventory.set-item") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:inventory.set_item") + static private extern(C) void __import_setItem(uint, uint, uint, uint) nothrow; + + /++ + Removes and returns the item in the specified slot index. + +/ + Option!(ItemStack) removeItem(uint slot) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_removeItem(this.__handle, slot, _retArea.ptr); + Option!(ItemStack) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = ItemStack(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(ItemStack).makeSome(_handle2); + } else { + _option3 = Option!(ItemStack).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]inventory.remove-item") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:inventory.remove_item") + static private extern(C) void __import_removeItem(uint, uint, void*) nothrow; + + /++ + Clears all items from this inventory. + +/ + void clear() @trusted nothrow { + __import_clear(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]inventory.clear") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:inventory.clear") + static private extern(C) void __import_clear(uint) nothrow; + + /++ + Returns all items in this inventory as a list of slots. + +/ + WitList!(Option!(ItemStack)) getAllItems() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getAllItems(this.__handle, _retArea.ptr); + auto _listSrcPtr5 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen5 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list5 = _listLen5 ? wit.common.mallocSlice!(Option!(ItemStack))(_listLen5) : []; + assert(!_listLen5 || _list5.ptr); + foreach (_elem0_idx, ref _elem0; _list5) { + const auto _base0 = _listSrcPtr5 + _elem0_idx * 8; + Option!(ItemStack) _option4 = void; + bool _isSome4 = (cast(uint)(*(cast(ubyte*)(_base0 + 0)))) != 0; + if (_isSome4) { + auto _handle3 = ItemStack(*(cast(uint*)(_base0 + 4))); + + _option4 = Option!(ItemStack).makeSome(_handle3); + } else { + _option4 = Option!(ItemStack).makeNone; + } + _elem0 = _option4; + } + if (_listLen5) wit.common.free(_listSrcPtr5); + auto _witList6 = WitList!(Option!(ItemStack))(_list5); + auto _flush7 = _witList6; + return _flush7; + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]inventory.get-all-items") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:inventory.get_all_items") + static private extern(C) void __import_getAllItems(uint, void*) nothrow; + + /++ + Sets all items in this inventory from a list. + +/ + void setAllItems(in WitList!(Option!(ItemStack)) items) @trusted nothrow { + wit.common.DeallocateBuffer deallocate; + auto _listSrc5 = items; + auto _list5 = _listSrc5.length ? wit.common.malloc(_listSrc5.length * (8)) : null; + assert(!_listSrc5.length || _list5); + if (_listSrc5.length) deallocate ~= _list5; + foreach (_elem0_idx, ref _elem0; _listSrc5) { + auto _base0 = _list5 + _elem0_idx * (8); + if (_elem0.isSome) { + ref _payload4 = _elem0.unwrap(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(1); + *cast(uint*)(_base0 + 4) = cast(uint)(_payload4.__handle); + } else { + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(0); + } + + } + __import_setAllItems(this.__handle, _list5, items.length); + deallocate.purge(); + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]inventory.set-all-items") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:inventory.set_all_items") + static private extern(C) void __import_setAllItems(uint, void*, size_t) nothrow; + + /++ + Counts the total number of items with the given ID in this inventory. + +/ + uint countItem(in WitString itemId) @trusted nothrow { + auto _ret = __import_countItem(this.__handle, cast(void*)(itemId.ptr), itemId.length); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]inventory.count-item") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:inventory.count_item") + static private extern(C) uint __import_countItem(uint, void*, size_t) nothrow; + + /++ + Checks if the inventory contains at least one item with the given ID. + +/ + bool containsItem(in WitString itemId) @trusted nothrow { + auto _ret = __import_containsItem(this.__handle, cast(void*)(itemId.ptr), itemId.length); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]inventory.contains-item") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:inventory.contains_item") + static private extern(C) uint __import_containsItem(uint, void*, size_t) nothrow; + } +} + +/++ +Specialized player inventory handle providing access to main inventory, armor, offhand, and hotbar. ++/ +struct PlayerInventory { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[resource-drop]player-inventory") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:resource_drop:player_inventory") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + Returns the generic 36-slot inventory handle (hotbar + main storage). + +/ + Inventory asInventory() @trusted nothrow { + auto _ret = __import_asInventory(this.__handle); + auto _handle0 = Inventory(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]player-inventory.as-inventory") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:player_inventory.as_inventory") + static private extern(C) uint __import_asInventory(uint) nothrow; + + /++ + Returns the item currently held in the specified hand. + +/ + Option!(ItemStack) getItemInHand(Hand hand) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getItemInHand(this.__handle, cast(uint)(hand), _retArea.ptr); + Option!(ItemStack) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = ItemStack(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(ItemStack).makeSome(_handle2); + } else { + _option3 = Option!(ItemStack).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]player-inventory.get-item-in-hand") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:player_inventory.get_item_in_hand") + static private extern(C) void __import_getItemInHand(uint, uint, void*) nothrow; + + /++ + Sets the item in the specified hand. + +/ + void setItemInHand(Hand hand, in Option!(ItemStack) item) @trusted nothrow { + uint _option4 = void; + uint _option5 = void; + if (item.isSome) { + ref _payload3 = item.unwrap(); + _option4 = 1; + _option5 = _payload3.__handle; + } else { + _option4 = 0; + _option5 = 0; + } + __import_setItemInHand(this.__handle, cast(uint)(hand), _option4, _option5); + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]player-inventory.set-item-in-hand") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:player_inventory.set_item_in_hand") + static private extern(C) void __import_setItemInHand(uint, uint, uint, uint) nothrow; + + /++ + Returns the currently selected hotbar slot index (0-8). + +/ + ubyte getSelectedSlot() @trusted nothrow { + auto _ret = __import_getSelectedSlot(this.__handle); + return cast(ubyte)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]player-inventory.get-selected-slot") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:player_inventory.get_selected_slot") + static private extern(C) uint __import_getSelectedSlot(uint) nothrow; + + /++ + Sets the currently selected hotbar slot index (0-8). + +/ + void setSelectedSlot(ubyte slot) @trusted nothrow { + __import_setSelectedSlot(this.__handle, cast(uint)(slot)); + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]player-inventory.set-selected-slot") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:player_inventory.set_selected_slot") + static private extern(C) void __import_setSelectedSlot(uint, uint) nothrow; + + /++ + Armor slot accessors + +/ + Option!(ItemStack) getHelmet() @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getHelmet(this.__handle, _retArea.ptr); + Option!(ItemStack) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = ItemStack(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(ItemStack).makeSome(_handle2); + } else { + _option3 = Option!(ItemStack).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]player-inventory.get-helmet") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:player_inventory.get_helmet") + static private extern(C) void __import_getHelmet(uint, void*) nothrow; + + /++ + + +/ + void setHelmet(in Option!(ItemStack) item) @trusted nothrow { + uint _option4 = void; + uint _option5 = void; + if (item.isSome) { + ref _payload3 = item.unwrap(); + _option4 = 1; + _option5 = _payload3.__handle; + } else { + _option4 = 0; + _option5 = 0; + } + __import_setHelmet(this.__handle, _option4, _option5); + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]player-inventory.set-helmet") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:player_inventory.set_helmet") + static private extern(C) void __import_setHelmet(uint, uint, uint) nothrow; + + /++ + + +/ + Option!(ItemStack) getChestplate() @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getChestplate(this.__handle, _retArea.ptr); + Option!(ItemStack) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = ItemStack(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(ItemStack).makeSome(_handle2); + } else { + _option3 = Option!(ItemStack).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]player-inventory.get-chestplate") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:player_inventory.get_chestplate") + static private extern(C) void __import_getChestplate(uint, void*) nothrow; + + /++ + + +/ + void setChestplate(in Option!(ItemStack) item) @trusted nothrow { + uint _option4 = void; + uint _option5 = void; + if (item.isSome) { + ref _payload3 = item.unwrap(); + _option4 = 1; + _option5 = _payload3.__handle; + } else { + _option4 = 0; + _option5 = 0; + } + __import_setChestplate(this.__handle, _option4, _option5); + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]player-inventory.set-chestplate") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:player_inventory.set_chestplate") + static private extern(C) void __import_setChestplate(uint, uint, uint) nothrow; + + /++ + + +/ + Option!(ItemStack) getLeggings() @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getLeggings(this.__handle, _retArea.ptr); + Option!(ItemStack) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = ItemStack(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(ItemStack).makeSome(_handle2); + } else { + _option3 = Option!(ItemStack).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]player-inventory.get-leggings") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:player_inventory.get_leggings") + static private extern(C) void __import_getLeggings(uint, void*) nothrow; + + /++ + + +/ + void setLeggings(in Option!(ItemStack) item) @trusted nothrow { + uint _option4 = void; + uint _option5 = void; + if (item.isSome) { + ref _payload3 = item.unwrap(); + _option4 = 1; + _option5 = _payload3.__handle; + } else { + _option4 = 0; + _option5 = 0; + } + __import_setLeggings(this.__handle, _option4, _option5); + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]player-inventory.set-leggings") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:player_inventory.set_leggings") + static private extern(C) void __import_setLeggings(uint, uint, uint) nothrow; + + /++ + + +/ + Option!(ItemStack) getBoots() @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getBoots(this.__handle, _retArea.ptr); + Option!(ItemStack) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = ItemStack(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(ItemStack).makeSome(_handle2); + } else { + _option3 = Option!(ItemStack).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]player-inventory.get-boots") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:player_inventory.get_boots") + static private extern(C) void __import_getBoots(uint, void*) nothrow; + + /++ + + +/ + void setBoots(in Option!(ItemStack) item) @trusted nothrow { + uint _option4 = void; + uint _option5 = void; + if (item.isSome) { + ref _payload3 = item.unwrap(); + _option4 = 1; + _option5 = _payload3.__handle; + } else { + _option4 = 0; + _option5 = 0; + } + __import_setBoots(this.__handle, _option4, _option5); + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]player-inventory.set-boots") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:player_inventory.set_boots") + static private extern(C) void __import_setBoots(uint, uint, uint) nothrow; + + /++ + + +/ + Option!(ItemStack) getOffHand() @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getOffHand(this.__handle, _retArea.ptr); + Option!(ItemStack) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = ItemStack(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(ItemStack).makeSome(_handle2); + } else { + _option3 = Option!(ItemStack).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]player-inventory.get-off-hand") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:player_inventory.get_off_hand") + static private extern(C) void __import_getOffHand(uint, void*) nothrow; + + /++ + + +/ + void setOffHand(in Option!(ItemStack) item) @trusted nothrow { + uint _option4 = void; + uint _option5 = void; + if (item.isSome) { + ref _payload3 = item.unwrap(); + _option4 = 1; + _option5 = _payload3.__handle; + } else { + _option4 = 0; + _option5 = 0; + } + __import_setOffHand(this.__handle, _option4, _option5); + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]player-inventory.set-off-hand") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:player_inventory.set_off_hand") + static private extern(C) void __import_setOffHand(uint, uint, uint) nothrow; + + /++ + Clears all armor slots. + +/ + void clearArmor() @trusted nothrow { + __import_clearArmor(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]player-inventory.clear-armor") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:player_inventory.clear_armor") + static private extern(C) void __import_clearArmor(uint) nothrow; + + /++ + Clears the 36 main inventory slots. + +/ + void clearMain() @trusted nothrow { + __import_clearMain(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]player-inventory.clear-main") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:player_inventory.clear_main") + static private extern(C) void __import_clearMain(uint) nothrow; + + /++ + Clears all slots (main inventory, armor, offhand). + +/ + void clearAll() @trusted nothrow { + __import_clearAll(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/inventory@0.1.0", "[method]player-inventory.clear-all") + pragma(mangle, "__wit_import_pumpkin:plugin__inventory@0.1.0__:method:player_inventory.clear_all") + static private extern(C) void __import_clearAll(uint) nothrow; + } +} diff --git a/src/wit/pumpkin/plugin/ipc/common.d b/src/wit/pumpkin/plugin/ipc/common.d new file mode 100644 index 0000000..a7b795f --- /dev/null +++ b/src/wit/pumpkin/plugin/ipc/common.d @@ -0,0 +1,20 @@ +/++ + ++/ +module wit.pumpkin.plugin.ipc.common; + + +import wit.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias PluginId = WitString; + +/++ + ++/ +alias IpcMessage = WitList!(ubyte); \ No newline at end of file diff --git a/src/wit/pumpkin/plugin/ipc/imports.d b/src/wit/pumpkin/plugin/ipc/imports.d new file mode 100644 index 0000000..5f94242 --- /dev/null +++ b/src/wit/pumpkin/plugin/ipc/imports.d @@ -0,0 +1,50 @@ +/++ + ++/ +module wit.pumpkin.plugin.ipc.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.ipc.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ +Sends a message to the specified plugin, synchronously receiving a response (or an error). ++/ +Result!(Result!(IpcMessage, WitString), void) sendIpcMessage(in PluginId recipient, in IpcMessage message) @trusted nothrow { + align(size_t.sizeof) void[(4*size_t.sizeof)] _retArea = void; + __import_sendIpcMessage(cast(void*)(recipient.ptr), recipient.length, cast(void*)(message.ptr), message.length, _retArea.ptr); + Result!(Result!(IpcMessage, WitString), void) _result9 = void; + bool _isErr9 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isErr9) { + + _result9 = Result!(Result!(IpcMessage, WitString), void).makeErr(); + } else { + Result!(IpcMessage, WitString) _result7 = void; + bool _isErr7 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + size_t.sizeof)))) != 0; + if (_isErr7) { + auto _len5 = *(cast(size_t*)(_retArea.ptr + (3*size_t.sizeof))); + auto _ptr5 = _len5 ? cast(char*)(*(cast(void**)(_retArea.ptr + (2*size_t.sizeof)))) : null; + auto _list6 = WitString(_ptr5[0.._len5]); + + _result7 = Result!(IpcMessage, WitString).makeErr(_list6); + } else { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (3*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(ubyte*)(*(cast(void**)(_retArea.ptr + (2*size_t.sizeof)))) : null; + auto _list3 = IpcMessage(_ptr2[0.._len2]); + + _result7 = Result!(IpcMessage, WitString).makeOk(_list3); + } + + _result9 = Result!(Result!(IpcMessage, WitString), void).makeOk(_result7); + } + auto _flush10 = _result9; + return _flush10; +} +/// ditto +@wasmImport!("pumpkin:plugin/ipc@0.1.0", "send-ipc-message") +pragma(mangle, "__wit_import_pumpkin:plugin__ipc@0.1.0__send_ipc_message") +private extern(C) void __import_sendIpcMessage(void*, size_t, void*, size_t, void*) nothrow; diff --git a/src/wit/pumpkin/plugin/item_stack/common.d b/src/wit/pumpkin/plugin/item_stack/common.d new file mode 100644 index 0000000..72561c6 --- /dev/null +++ b/src/wit/pumpkin/plugin/item_stack/common.d @@ -0,0 +1,176 @@ +/++ + ++/ +module wit.pumpkin.plugin.item_stack.common; + + +import wit.common; + +static import wit.pumpkin.plugin.attributes.common; +static import wit.pumpkin.plugin.common.common; +static import wit.pumpkin.plugin.data_components.common; +static import wit.pumpkin.plugin.text.common; +static import wit.pumpkin.plugin.enchantments.common; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias Attribute = wit.pumpkin.plugin.attributes.common.Attribute; + +/++ + ++/ +alias AttributeModifier = wit.pumpkin.plugin.attributes.common.AttributeModifier; + +/++ + ++/ +alias DataComponent = wit.pumpkin.plugin.data_components.common.DataComponent; + +/++ + ++/ +alias AttributeModifierSlot = wit.pumpkin.plugin.enchantments.common.AttributeModifierSlot; + +/++ + ++/ +alias Enchantment = wit.pumpkin.plugin.enchantments.common.Enchantment; + +/++ + ++/ +alias NbtEntry = wit.pumpkin.plugin.common.common.NbtEntry; + +/++ + ++/ +alias NbtTree = wit.pumpkin.plugin.common.common.NbtTree; + +/++ + ++/ +alias NbtTag = wit.pumpkin.plugin.common.common.NbtTag; + +/++ +Represents an enchantment and its level. ++/ +struct EnchantmentValue { + /++ + + +/ + Enchantment enchantment; + + /++ + + +/ + uint level; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EnchantmentValue witClone() const @nogc nothrow { + EnchantmentValue clone = void; + clone.enchantment = this.enchantment.witClone; + clone.level = this.level.witClone; + return clone; + } +} + +/++ +Represents a custom enchantment and its level on an item stack. ++/ +struct CustomEnchantmentValue { + /++ + + +/ + WitString enchantmentId; + + /++ + + +/ + uint level; + + void witFree() @nogc nothrow { + enchantmentId.witFree; + } + + void witDrop() @nogc nothrow { + } + + CustomEnchantmentValue witClone() const @nogc nothrow { + CustomEnchantmentValue clone = void; + clone.enchantmentId = this.enchantmentId.witClone; + clone.level = this.level.witClone; + return clone; + } +} + +/++ +Represents an attribute modifier applied to an item stack for a specific slot. ++/ +struct ItemAttributeModifier { + /++ + + +/ + Attribute attribute; + + /++ + + +/ + AttributeModifier modifier; + + /++ + + +/ + AttributeModifierSlot slot; + + void witFree() @nogc nothrow { + modifier.witFree; + } + + void witDrop() @nogc nothrow { + } + + ItemAttributeModifier witClone() const @nogc nothrow { + ItemAttributeModifier clone = void; + clone.attribute = this.attribute.witClone; + clone.modifier = this.modifier.witClone; + clone.slot = this.slot.witClone; + return clone; + } +} + +/++ +Represents a data component and its serialized value. ++/ +struct DataComponentValue { + /++ + + +/ + DataComponent component; + + /++ + The serialized value of the component. + +/ + WitList!(ubyte) value; + + void witFree() @nogc nothrow { + value.witFree; + } + + void witDrop() @nogc nothrow { + } + + DataComponentValue witClone() const @nogc nothrow { + DataComponentValue clone = void; + clone.component = this.component.witClone; + clone.value = this.value.witClone; + return clone; + } +} diff --git a/src/wit/pumpkin/plugin/item_stack/imports.d b/src/wit/pumpkin/plugin/item_stack/imports.d new file mode 100644 index 0000000..4913e23 --- /dev/null +++ b/src/wit/pumpkin/plugin/item_stack/imports.d @@ -0,0 +1,742 @@ +/++ + ++/ +module wit.pumpkin.plugin.item_stack.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.item_stack.common; + +static import wit.pumpkin.plugin.attributes.imports; +static import wit.pumpkin.plugin.common.imports; +static import wit.pumpkin.plugin.data_components.imports; +static import wit.pumpkin.plugin.text.imports; +static import wit.pumpkin.plugin.enchantments.imports; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias TextComponent = wit.pumpkin.plugin.text.imports.TextComponent; + +/++ + ++/ +struct ItemStack { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + /++ + + +/ + static ItemStack makeNew(in WitString registryKey, ubyte count) @trusted nothrow { + auto _ret = __import_makeNew(cast(void*)(registryKey.ptr), registryKey.length, cast(uint)(count)); + auto _handle0 = ItemStack(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[constructor]item-stack") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:constructor:item_stack") + static private extern(C) uint __import_makeNew(void*, size_t, uint) nothrow; + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[resource-drop]item-stack") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:resource_drop:item_stack") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + Returns the unique registry key of the item (e.g., "minecraft:diamond"). + +/ + WitString getRegistryKey() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getRegistryKey(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.get-registry-key") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.get_registry_key") + static private extern(C) void __import_getRegistryKey(uint, void*) nothrow; + + /++ + Returns the number of items in the stack. + +/ + ubyte getCount() @trusted nothrow { + auto _ret = __import_getCount(this.__handle); + return cast(ubyte)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.get-count") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.get_count") + static private extern(C) uint __import_getCount(uint) nothrow; + + /++ + Sets the number of items in the stack. + +/ + void setCount(ubyte count) @trusted nothrow { + __import_setCount(this.__handle, cast(uint)(count)); + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.set-count") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.set_count") + static private extern(C) void __import_setCount(uint, uint) nothrow; + + /++ + Returns the maximum number of items that can be in this stack. + +/ + ubyte getMaxCount() @trusted nothrow { + auto _ret = __import_getMaxCount(this.__handle); + return cast(ubyte)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.get-max-count") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.get_max_count") + static private extern(C) uint __import_getMaxCount(uint) nothrow; + + /++ + Returns all enchantments on this item stack. + +/ + WitList!(EnchantmentValue) getEnchantments() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getEnchantments(this.__handle, _retArea.ptr); + auto _listSrcPtr2 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen2 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list2 = _listLen2 ? wit.common.mallocSlice!(EnchantmentValue)(_listLen2) : []; + assert(!_listLen2 || _list2.ptr); + foreach (_elem0_idx, ref _elem0; _list2) { + const auto _base0 = _listSrcPtr2 + _elem0_idx * 8; + EnchantmentValue _record1 = { + enchantment: cast(wit.pumpkin.plugin.enchantments.imports.Enchantment)(cast(uint)(*(cast(ubyte*)(_base0 + 0)))), + level: *(cast(uint*)(_base0 + 4)), + }; + _elem0 = _record1; + } + if (_listLen2) wit.common.free(_listSrcPtr2); + auto _witList3 = WitList!(EnchantmentValue)(_list2); + auto _flush4 = _witList3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.get-enchantments") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.get_enchantments") + static private extern(C) void __import_getEnchantments(uint, void*) nothrow; + + /++ + Adds an enchantment to this item stack. + +/ + void addEnchantment(Enchantment enchantment, uint level) @trusted nothrow { + __import_addEnchantment(this.__handle, cast(uint)(enchantment), level); + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.add-enchantment") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.add_enchantment") + static private extern(C) void __import_addEnchantment(uint, uint, uint) nothrow; + + /++ + Removes an enchantment from this item stack. + +/ + void removeEnchantment(Enchantment enchantment) @trusted nothrow { + __import_removeEnchantment(this.__handle, cast(uint)(enchantment)); + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.remove-enchantment") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.remove_enchantment") + static private extern(C) void __import_removeEnchantment(uint, uint) nothrow; + + /++ + Returns all custom enchantments on this item stack. + +/ + WitList!(CustomEnchantmentValue) getCustomEnchantments() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getCustomEnchantments(this.__handle, _retArea.ptr); + auto _listSrcPtr4 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen4 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list4 = _listLen4 ? wit.common.mallocSlice!(CustomEnchantmentValue)(_listLen4) : []; + assert(!_listLen4 || _list4.ptr); + foreach (_elem0_idx, ref _elem0; _list4) { + const auto _base0 = _listSrcPtr4 + _elem0_idx * (3*size_t.sizeof); + auto _len1 = *(cast(size_t*)(_base0 + size_t.sizeof)); + auto _ptr1 = _len1 ? cast(char*)(*(cast(void**)(_base0 + 0))) : null; + auto _list2 = WitString(_ptr1[0.._len1]); + CustomEnchantmentValue _record3 = { + enchantmentId: _list2, + level: *(cast(uint*)(_base0 + (2*size_t.sizeof))), + }; + _elem0 = _record3; + } + if (_listLen4) wit.common.free(_listSrcPtr4); + auto _witList5 = WitList!(CustomEnchantmentValue)(_list4); + auto _flush6 = _witList5; + return _flush6; + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.get-custom-enchantments") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.get_custom_enchantments") + static private extern(C) void __import_getCustomEnchantments(uint, void*) nothrow; + + /++ + Adds a custom enchantment to this item stack. + +/ + void addCustomEnchantment(in WitString enchantmentId, uint level) @trusted nothrow { + __import_addCustomEnchantment(this.__handle, cast(void*)(enchantmentId.ptr), enchantmentId.length, level); + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.add-custom-enchantment") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.add_custom_enchantment") + static private extern(C) void __import_addCustomEnchantment(uint, void*, size_t, uint) nothrow; + + /++ + Removes a custom enchantment from this item stack. + +/ + void removeCustomEnchantment(in WitString enchantmentId) @trusted nothrow { + __import_removeCustomEnchantment(this.__handle, cast(void*)(enchantmentId.ptr), enchantmentId.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.remove-custom-enchantment") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.remove_custom_enchantment") + static private extern(C) void __import_removeCustomEnchantment(uint, void*, size_t) nothrow; + + /++ + Returns the level of a custom enchantment on this item stack, if present. + +/ + Option!(uint) getCustomEnchantmentLevel(in WitString enchantmentId) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getCustomEnchantmentLevel(this.__handle, cast(void*)(enchantmentId.ptr), enchantmentId.length, _retArea.ptr); + Option!(uint) _option2 = void; + bool _isSome2 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome2) { + + _option2 = Option!(uint).makeSome(*(cast(uint*)(_retArea.ptr + 4))); + } else { + _option2 = Option!(uint).makeNone; + } + auto _flush3 = _option2; + return _flush3; + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.get-custom-enchantment-level") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.get_custom_enchantment_level") + static private extern(C) void __import_getCustomEnchantmentLevel(uint, void*, size_t, void*) nothrow; + + /++ + Returns whether this item stack has a specific custom enchantment. + +/ + bool hasCustomEnchantment(in WitString enchantmentId) @trusted nothrow { + auto _ret = __import_hasCustomEnchantment(this.__handle, cast(void*)(enchantmentId.ptr), enchantmentId.length); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.has-custom-enchantment") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.has_custom_enchantment") + static private extern(C) uint __import_hasCustomEnchantment(uint, void*, size_t) nothrow; + + /++ + Returns all attribute modifiers on this item stack. + +/ + WitList!(ItemAttributeModifier) getAttributeModifiers() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getAttributeModifiers(this.__handle, _retArea.ptr); + auto _listSrcPtr5 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen5 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list5 = _listLen5 ? wit.common.mallocSlice!(ItemAttributeModifier)(_listLen5) : []; + assert(!_listLen5 || _list5.ptr); + foreach (_elem0_idx, ref _elem0; _list5) { + const auto _base0 = _listSrcPtr5 + _elem0_idx * (32+2*size_t.sizeof); + auto _len1 = *(cast(size_t*)(_base0 + (8+1*size_t.sizeof))); + auto _ptr1 = _len1 ? cast(char*)(*(cast(void**)(_base0 + 8))) : null; + auto _list2 = WitString(_ptr1[0.._len1]); + wit.pumpkin.plugin.attributes.imports.AttributeModifier _record3 = { + id: _list2, + amount: *(cast(double*)(_base0 + (8+2*size_t.sizeof))), + operation: cast(wit.pumpkin.plugin.attributes.imports.ModifierOperation)(cast(uint)(*(cast(ubyte*)(_base0 + (16+2*size_t.sizeof))))), + }; + ItemAttributeModifier _record4 = { + attribute: cast(wit.pumpkin.plugin.attributes.imports.Attribute)(cast(uint)(*(cast(ubyte*)(_base0 + 0)))), + modifier: _record3, + slot: cast(wit.pumpkin.plugin.enchantments.imports.AttributeModifierSlot)(cast(uint)(*(cast(ubyte*)(_base0 + (24+2*size_t.sizeof))))), + }; + _elem0 = _record4; + } + if (_listLen5) wit.common.free(_listSrcPtr5); + auto _witList6 = WitList!(ItemAttributeModifier)(_list5); + auto _flush7 = _witList6; + return _flush7; + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.get-attribute-modifiers") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.get_attribute_modifiers") + static private extern(C) void __import_getAttributeModifiers(uint, void*) nothrow; + + /++ + Adds an attribute modifier to this item stack. + +/ + void addAttributeModifier(in ItemAttributeModifier modifier) @trusted nothrow { + __import_addAttributeModifier(this.__handle, cast(uint)(modifier.attribute), cast(void*)(modifier.modifier.id.ptr), modifier.modifier.id.length, modifier.modifier.amount, cast(uint)(modifier.modifier.operation), cast(uint)(modifier.slot)); + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.add-attribute-modifier") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.add_attribute_modifier") + static private extern(C) void __import_addAttributeModifier(uint, uint, void*, size_t, double, uint, uint) nothrow; + + /++ + Removes all attribute modifiers for a specific attribute from this item stack. + +/ + void removeAttributeModifiers(Attribute attribute) @trusted nothrow { + __import_removeAttributeModifiers(this.__handle, cast(uint)(attribute)); + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.remove-attribute-modifiers") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.remove_attribute_modifiers") + static private extern(C) void __import_removeAttributeModifiers(uint, uint) nothrow; + + /++ + Clears all custom attribute modifiers from this item stack. + +/ + void clearAttributeModifiers() @trusted nothrow { + __import_clearAttributeModifiers(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.clear-attribute-modifiers") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.clear_attribute_modifiers") + static private extern(C) void __import_clearAttributeModifiers(uint) nothrow; + + /++ + Returns the lore of this item stack. + +/ + WitList!(TextComponent) getLore() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getLore(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(TextComponent*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitList!(TextComponent)(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.get-lore") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.get_lore") + static private extern(C) void __import_getLore(uint, void*) nothrow; + + /++ + Sets the lore of this item stack. + +/ + void setLore(in WitList!(TextComponent) lore) @trusted nothrow { + __import_setLore(this.__handle, cast(void*)(lore.ptr), lore.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.set-lore") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.set_lore") + static private extern(C) void __import_setLore(uint, void*, size_t) nothrow; + + /++ + Adds a line to the lore of this item stack. + +/ + void addLore(TextComponent line) @trusted nothrow { + __import_addLore(this.__handle, line.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.add-lore") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.add_lore") + static private extern(C) void __import_addLore(uint, uint) nothrow; + + /++ + Returns the custom name of this item stack, if set. + +/ + Option!(TextComponent) getCustomName() @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getCustomName(this.__handle, _retArea.ptr); + Option!(TextComponent) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = TextComponent(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(TextComponent).makeSome(_handle2); + } else { + _option3 = Option!(TextComponent).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.get-custom-name") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.get_custom_name") + static private extern(C) void __import_getCustomName(uint, void*) nothrow; + + /++ + Sets the custom name of this item stack. + +/ + void setCustomName(in Option!(TextComponent) name) @trusted nothrow { + uint _option4 = void; + uint _option5 = void; + if (name.isSome) { + ref _payload3 = name.unwrap(); + _option4 = 1; + _option5 = _payload3.__handle; + } else { + _option4 = 0; + _option5 = 0; + } + __import_setCustomName(this.__handle, _option4, _option5); + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.set-custom-name") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.set_custom_name") + static private extern(C) void __import_setCustomName(uint, uint, uint) nothrow; + + /++ + Sets a namespaced custom data value on this item stack. + +/ + void setCustomData(in WitString namespace, in WitString key, in NbtTree value) @trusted nothrow { + wit.common.DeallocateBuffer deallocate; + auto _listSrc28 = value.tags; + auto _list28 = _listSrc28.length ? wit.common.malloc(_listSrc28.length * ((8+2*size_t.sizeof))) : null; + assert(!_listSrc28.length || _list28); + if (_listSrc28.length) deallocate ~= _list28; + foreach (_elem0_idx, ref _elem0; _listSrc28) { + auto _base0 = _list28 + _elem0_idx * ((8+2*size_t.sizeof)); + alias _Tag27 = wit.pumpkin.plugin.common.imports.NbtTag.Tag; + final switch (_elem0.tag) { + case _Tag27.byte_: { + const ref byte _payload2 = _elem0.getByte(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(0); + *cast(ubyte*)(_base0 + 8) = cast(ubyte)(cast(uint)(_payload2)); + break; + } + case _Tag27.short_: { + const ref short _payload4 = _elem0.getShort(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(1); + *cast(ushort*)(_base0 + 8) = cast(ushort)(cast(uint)(_payload4)); + break; + } + case _Tag27.int_: { + const ref int _payload6 = _elem0.getInt(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(2); + *cast(uint*)(_base0 + 8) = cast(uint)(cast(uint)(_payload6)); + break; + } + case _Tag27.long_: { + const ref long _payload8 = _elem0.getLong(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(3); + *cast(ulong*)(_base0 + 8) = cast(ulong)(cast(ulong)(_payload8)); + break; + } + case _Tag27.float_: { + const ref float _payload10 = _elem0.getFloat(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(4); + *cast(float*)(_base0 + 8) = cast(float)(_payload10); + break; + } + case _Tag27.double_: { + const ref double _payload12 = _elem0.getDouble(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(5); + *cast(double*)(_base0 + 8) = cast(double)(_payload12); + break; + } + case _Tag27.byteArray: { + const ref WitList!(byte) _payload14 = _elem0.getByteArray(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(6); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload14.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload14.ptr)); + break; + } + case _Tag27.stringTag: { + const ref WitString _payload16 = _elem0.getStringTag(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(7); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload16.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload16.ptr)); + break; + } + case _Tag27.listTag: { + const ref WitList!(uint) _payload18 = _elem0.getListTag(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(8); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload18.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload18.ptr)); + break; + } + case _Tag27.compound: { + const ref WitList!(wit.pumpkin.plugin.common.imports.NbtEntry) _payload20 = _elem0.getCompound(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(9); + auto _listSrc22 = _payload20; + auto _list22 = _listSrc22.length ? wit.common.malloc(_listSrc22.length * ((3*size_t.sizeof))) : null; + assert(!_listSrc22.length || _list22); + if (_listSrc22.length) deallocate ~= _list22; + foreach (_elem21_idx, ref _elem21; _listSrc22) { + auto _base21 = _list22 + _elem21_idx * ((3*size_t.sizeof)); + *cast(size_t*)(_base21 + size_t.sizeof) = cast(size_t)(_elem21.key.length); + *cast(void**)(_base21 + 0) = cast(void*)(cast(void*)(_elem21.key.ptr)); + *cast(uint*)(_base21 + (2*size_t.sizeof)) = cast(uint)(_elem21.value); + + } + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload20.length); + *cast(void**)(_base0 + 8) = cast(void*)(_list22); + break; + } + case _Tag27.intArray: { + const ref WitList!(int) _payload24 = _elem0.getIntArray(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(10); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload24.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload24.ptr)); + break; + } + case _Tag27.longArray: { + const ref WitList!(long) _payload26 = _elem0.getLongArray(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(11); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload26.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload26.ptr)); + break; + } + } + + } + __import_setCustomData(this.__handle, cast(void*)(namespace.ptr), namespace.length, cast(void*)(key.ptr), key.length, value.root, _list28, value.tags.length); + deallocate.purge(); + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.set-custom-data") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.set_custom_data") + static private extern(C) void __import_setCustomData(uint, void*, size_t, void*, size_t, uint, void*, size_t) nothrow; + + /++ + Returns a namespaced custom data value from this item stack, if set. + +/ + Option!(NbtTree) getCustomData(in WitString namespace, in WitString key) @trusted nothrow { + align(size_t.sizeof) void[(4*size_t.sizeof)] _retArea = void; + __import_getCustomData(this.__handle, cast(void*)(namespace.ptr), namespace.length, cast(void*)(key.ptr), key.length, _retArea.ptr); + Option!(NbtTree) _option47 = void; + bool _isSome47 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome47) { + auto _listSrcPtr44 = *(cast(void**)(_retArea.ptr + (2*size_t.sizeof))); + auto _listLen44 = *(cast(size_t*)(_retArea.ptr + (3*size_t.sizeof))); + auto _list44 = _listLen44 ? wit.common.mallocSlice!(wit.pumpkin.plugin.common.imports.NbtTag)(_listLen44) : []; + assert(!_listLen44 || _list44.ptr); + foreach (_elem2_idx, ref _elem2; _list44) { + const auto _base2 = _listSrcPtr44 + _elem2_idx * (8+2*size_t.sizeof); + wit.pumpkin.plugin.common.imports.NbtTag _variant31 = void; + auto _tag31 = cast(uint)(*(cast(ubyte*)(_base2 + 0))); + alias _Tag31 = wit.pumpkin.plugin.common.imports.NbtTag.Tag; + final switch (cast(wit.pumpkin.plugin.common.imports.NbtTag.Tag)_tag31) { + case _Tag31.byte_: { + auto _payload32 = cast(byte)(cast(uint)(*(cast(byte*)(_base2 + 8)))); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.byte_(_payload32); + break; + } + case _Tag31.short_: { + auto _payload33 = cast(short)(cast(uint)(*(cast(short*)(_base2 + 8)))); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.short_(_payload33); + break; + } + case _Tag31.int_: { + auto _payload34 = cast(int)(*(cast(uint*)(_base2 + 8))); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.int_(_payload34); + break; + } + case _Tag31.long_: { + auto _payload35 = cast(long)(*(cast(ulong*)(_base2 + 8))); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.long_(_payload35); + break; + } + case _Tag31.float_: { + auto _payload36 = *(cast(float*)(_base2 + 8)); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.float_(_payload36); + break; + } + case _Tag31.double_: { + auto _payload37 = *(cast(double*)(_base2 + 8)); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.double_(_payload37); + break; + } + case _Tag31.byteArray: { + auto _len10 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr10 = _len10 ? cast(byte*)(*(cast(void**)(_base2 + 8))) : null; + auto _list11 = WitList!(byte)(_ptr10[0.._len10]); + auto _payload38 = _list11; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.byteArray(_payload38); + break; + } + case _Tag31.stringTag: { + auto _len13 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr13 = _len13 ? cast(char*)(*(cast(void**)(_base2 + 8))) : null; + auto _list14 = WitString(_ptr13[0.._len13]); + auto _payload39 = _list14; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.stringTag(_payload39); + break; + } + case _Tag31.listTag: { + auto _len16 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr16 = _len16 ? cast(uint*)(*(cast(void**)(_base2 + 8))) : null; + auto _list17 = WitList!(uint)(_ptr16[0.._len16]); + auto _payload40 = _list17; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.listTag(_payload40); + break; + } + case _Tag31.compound: { + auto _listSrcPtr23 = *(cast(void**)(_base2 + 8)); + auto _listLen23 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _list23 = _listLen23 ? wit.common.mallocSlice!(wit.pumpkin.plugin.common.imports.NbtEntry)(_listLen23) : []; + assert(!_listLen23 || _list23.ptr); + foreach (_elem19_idx, ref _elem19; _list23) { + const auto _base19 = _listSrcPtr23 + _elem19_idx * (3*size_t.sizeof); + auto _len20 = *(cast(size_t*)(_base19 + size_t.sizeof)); + auto _ptr20 = _len20 ? cast(char*)(*(cast(void**)(_base19 + 0))) : null; + auto _list21 = WitString(_ptr20[0.._len20]); + wit.pumpkin.plugin.common.imports.NbtEntry _record22 = { + key: _list21, + value: *(cast(uint*)(_base19 + (2*size_t.sizeof))), + }; + _elem19 = _record22; + } + if (_listLen23) wit.common.free(_listSrcPtr23); + auto _witList24 = WitList!(wit.pumpkin.plugin.common.imports.NbtEntry)(_list23); + auto _payload41 = _witList24; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.compound(_payload41); + break; + } + case _Tag31.intArray: { + auto _len26 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr26 = _len26 ? cast(int*)(*(cast(void**)(_base2 + 8))) : null; + auto _list27 = WitList!(int)(_ptr26[0.._len26]); + auto _payload42 = _list27; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.intArray(_payload42); + break; + } + case _Tag31.longArray: { + auto _len29 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr29 = _len29 ? cast(long*)(*(cast(void**)(_base2 + 8))) : null; + auto _list30 = WitList!(long)(_ptr29[0.._len29]); + auto _payload43 = _list30; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.longArray(_payload43); + break; + } + } + _elem2 = _variant31; + } + if (_listLen44) wit.common.free(_listSrcPtr44); + auto _witList45 = WitList!(wit.pumpkin.plugin.common.imports.NbtTag)(_list44); + wit.pumpkin.plugin.common.imports.NbtTree _record46 = { + root: *(cast(uint*)(_retArea.ptr + size_t.sizeof)), + tags: _witList45, + }; + + _option47 = Option!(NbtTree).makeSome(_record46); + } else { + _option47 = Option!(NbtTree).makeNone; + } + auto _flush48 = _option47; + return _flush48; + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.get-custom-data") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.get_custom_data") + static private extern(C) void __import_getCustomData(uint, void*, size_t, void*, size_t, void*) nothrow; + + /++ + Removes a namespaced custom data value from this item stack. + +/ + void removeCustomData(in WitString namespace, in WitString key) @trusted nothrow { + __import_removeCustomData(this.__handle, cast(void*)(namespace.ptr), namespace.length, cast(void*)(key.ptr), key.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.remove-custom-data") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.remove_custom_data") + static private extern(C) void __import_removeCustomData(uint, void*, size_t, void*, size_t) nothrow; + + /++ + Returns whether this item stack has a namespaced custom data value. + +/ + bool hasCustomData(in WitString namespace, in WitString key) @trusted nothrow { + auto _ret = __import_hasCustomData(this.__handle, cast(void*)(namespace.ptr), namespace.length, cast(void*)(key.ptr), key.length); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.has-custom-data") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.has_custom_data") + static private extern(C) uint __import_hasCustomData(uint, void*, size_t, void*, size_t) nothrow; + + /++ + Returns all data components on this item stack. + +/ + WitList!(DataComponentValue) getComponents() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getComponents(this.__handle, _retArea.ptr); + auto _listSrcPtr4 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen4 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list4 = _listLen4 ? wit.common.mallocSlice!(DataComponentValue)(_listLen4) : []; + assert(!_listLen4 || _list4.ptr); + foreach (_elem0_idx, ref _elem0; _list4) { + const auto _base0 = _listSrcPtr4 + _elem0_idx * (3*size_t.sizeof); + auto _len1 = *(cast(size_t*)(_base0 + (2*size_t.sizeof))); + auto _ptr1 = _len1 ? cast(ubyte*)(*(cast(void**)(_base0 + size_t.sizeof))) : null; + auto _list2 = WitList!(ubyte)(_ptr1[0.._len1]); + DataComponentValue _record3 = { + component: cast(wit.pumpkin.plugin.data_components.imports.DataComponent)(cast(uint)(*(cast(ubyte*)(_base0 + 0)))), + value: _list2, + }; + _elem0 = _record3; + } + if (_listLen4) wit.common.free(_listSrcPtr4); + auto _witList5 = WitList!(DataComponentValue)(_list4); + auto _flush6 = _witList5; + return _flush6; + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.get-components") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.get_components") + static private extern(C) void __import_getComponents(uint, void*) nothrow; + + /++ + Sets a data component on this item stack. + +/ + void setComponent(DataComponent component, in WitList!(ubyte) value) @trusted nothrow { + __import_setComponent(this.__handle, cast(uint)(component), cast(void*)(value.ptr), value.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.set-component") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.set_component") + static private extern(C) void __import_setComponent(uint, uint, void*, size_t) nothrow; + + /++ + Removes a data component from this item stack. + +/ + void removeComponent(DataComponent component) @trusted nothrow { + __import_removeComponent(this.__handle, cast(uint)(component)); + } + /// ditto + @wasmImport!("pumpkin:plugin/item-stack@0.1.0", "[method]item-stack.remove-component") + pragma(mangle, "__wit_import_pumpkin:plugin__item_stack@0.1.0__:method:item_stack.remove_component") + static private extern(C) void __import_removeComponent(uint, uint) nothrow; + } +} diff --git a/src/wit/pumpkin/plugin/java_dialogs/common.d b/src/wit/pumpkin/plugin/java_dialogs/common.d new file mode 100644 index 0000000..4b68a98 --- /dev/null +++ b/src/wit/pumpkin/plugin/java_dialogs/common.d @@ -0,0 +1,202 @@ +/++ +Provides types and utilities for displaying rich dialogs to Java Edition players. +These dialogs support various layouts, body elements (text and items), +and interactive inputs (checkboxes, text fields, sliders). ++/ +module wit.pumpkin.plugin.java_dialogs.common; + + +import wit.common; + +static import wit.pumpkin.plugin.text.common; +static import wit.pumpkin.plugin.item_stack.common; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ +Represents the layout and button configuration of a dialog. ++/ +enum DialogType : ubyte { + /++ + A simple dialog with a single "OK" button. + +/ + notice, + + /++ + A dialog with "Yes" and "No" buttons. + +/ + confirmation, + + /++ + A scrollable list of custom buttons. + +/ + multiAction, + + /++ + A list of buttons that open other registered dialogs. + +/ + dialogList, + + /++ + A dedicated menu for displaying server-related links. + +/ + serverLinks, +} +/++ +Defines what happens after a dialog is closed. ++/ +enum AfterAction : ubyte { + /++ + Returns the player to the previous screen (e.g., keeping an inventory open). + +/ + peek, + + /++ + Closes all open screens. + +/ + pop, +} +/++ +Represents a custom server-side action. ++/ +struct CustomClickAction { + /++ + A unique identifier for the action (sent back to the server). + +/ + WitString id; + + /++ + Optional binary data to send with the action. + +/ + Option!(WitList!(ubyte)) payload; + + void witFree() @nogc nothrow { + id.witFree; + payload.witFree; + } + + void witDrop() @nogc nothrow { + } + + CustomClickAction witClone() const @nogc nothrow { + CustomClickAction clone = void; + clone.id = this.id.witClone; + clone.payload = this.payload.witClone; + return clone; + } +} + +/++ +Represents an action triggered by a button click. ++/ +struct Action { + mixin WitVariant!( + WitString, // openUrl + CustomClickAction, // customClick + ); + +public: + enum Tag : ubyte { + /++ + Opens an external URL. + +/ + openUrl, + + /++ + Triggers a custom server-side callback with an ID and optional payload. + +/ + customClick, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + Opens an external URL. + +/ + alias openUrl = _create!(Tag.openUrl); + /// ditto + pragma(inline, true) bool isOpenUrl() const => _tag == Tag.openUrl; + ///ditto + alias getOpenUrl = _get!(Tag.openUrl); + + /++ + Triggers a custom server-side callback with an ID and optional payload. + +/ + alias customClick = _create!(Tag.customClick); + /// ditto + pragma(inline, true) bool isCustomClick() const => _tag == Tag.customClick; + ///ditto + alias getCustomClick = _get!(Tag.customClick); + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case openUrl: _get!(Tag.openUrl).witFree; break; + case customClick: _get!(Tag.customClick).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + } + + Action witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.openUrl: return _create!(Tag.openUrl)(this._get!(Tag.openUrl).witClone); break; + case Tag.customClick: return _create!(Tag.customClick)(this._get!(Tag.customClick).witClone); break; + } + } +} + +/++ +Built-in link types recognized by the Java Edition client. ++/ +enum LinkType : ubyte { + /++ + + +/ + bugReport, + + /++ + + +/ + communityGuidelines, + + /++ + + +/ + support, + + /++ + + +/ + status, + + /++ + + +/ + feedback, + + /++ + + +/ + community, + + /++ + + +/ + website, + + /++ + + +/ + forums, + + /++ + + +/ + news, + + /++ + + +/ + announcements, +} \ No newline at end of file diff --git a/src/wit/pumpkin/plugin/java_dialogs/imports.d b/src/wit/pumpkin/plugin/java_dialogs/imports.d new file mode 100644 index 0000000..acbcfe6 --- /dev/null +++ b/src/wit/pumpkin/plugin/java_dialogs/imports.d @@ -0,0 +1,555 @@ +/++ +Provides types and utilities for displaying rich dialogs to Java Edition players. +These dialogs support various layouts, body elements (text and items), +and interactive inputs (checkboxes, text fields, sliders). ++/ +module wit.pumpkin.plugin.java_dialogs.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.java_dialogs.common; + +static import wit.pumpkin.plugin.text.imports; +static import wit.pumpkin.plugin.item_stack.imports; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias TextComponent = wit.pumpkin.plugin.text.imports.TextComponent; + +/++ + ++/ +alias ItemStack = wit.pumpkin.plugin.item_stack.imports.ItemStack; + +/++ +Represents an element in the main content area of a dialog. ++/ +struct DialogBody { + mixin WitVariant!( + TextComponent, // plainMessage + ItemStack, // item + ); + +public: + enum Tag : ubyte { + /++ + A simple text message. + +/ + plainMessage, + + /++ + A visual item display. + +/ + item, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + A simple text message. + +/ + alias plainMessage = _create!(Tag.plainMessage); + /// ditto + pragma(inline, true) bool isPlainMessage() const => _tag == Tag.plainMessage; + ///ditto + alias getPlainMessage = _get!(Tag.plainMessage); + + /++ + A visual item display. + +/ + alias item = _create!(Tag.item); + /// ditto + pragma(inline, true) bool isItem() const => _tag == Tag.item; + ///ditto + alias getItem = _get!(Tag.item); + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + switch (_tag) with (Tag) { + case plainMessage: _get!(Tag.plainMessage).witDrop; break; + case item: _get!(Tag.item).witDrop; break; + default: break; + } + } + + DialogBody witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.plainMessage: return _create!(Tag.plainMessage)(this._get!(Tag.plainMessage).witClone); break; + case Tag.item: return _create!(Tag.item)(this._get!(Tag.item).witClone); break; + } + } +} + +/++ +A checkbox input control. ++/ +struct DialogInputBool { + /++ + + +/ + TextComponent label; + + /++ + + +/ + bool defaultValue; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + label.witDrop; + } + + DialogInputBool witClone() const @nogc nothrow { + DialogInputBool clone = void; + clone.label = this.label.witClone; + clone.defaultValue = this.defaultValue.witClone; + return clone; + } +} + +/++ +A text field input control. ++/ +struct DialogInputText { + /++ + + +/ + TextComponent label; + + /++ + + +/ + TextComponent placeholder; + + /++ + + +/ + WitString defaultValue; + + void witFree() @nogc nothrow { + defaultValue.witFree; + } + + void witDrop() @nogc nothrow { + label.witDrop; + placeholder.witDrop; + } + + DialogInputText witClone() const @nogc nothrow { + DialogInputText clone = void; + clone.label = this.label.witClone; + clone.placeholder = this.placeholder.witClone; + clone.defaultValue = this.defaultValue.witClone; + return clone; + } +} + +/++ +A numerical range slider input control. ++/ +struct DialogInputNumberRange { + /++ + + +/ + TextComponent label; + + /++ + + +/ + float minValue; + + /++ + + +/ + float maxValue; + + /++ + + +/ + float initialValue; + + /++ + + +/ + float step; + + /++ + + +/ + Option!(WitString) labelFormat; + + void witFree() @nogc nothrow { + labelFormat.witFree; + } + + void witDrop() @nogc nothrow { + label.witDrop; + } + + DialogInputNumberRange witClone() const @nogc nothrow { + DialogInputNumberRange clone = void; + clone.label = this.label.witClone; + clone.minValue = this.minValue.witClone; + clone.maxValue = this.maxValue.witClone; + clone.initialValue = this.initialValue.witClone; + clone.step = this.step.witClone; + clone.labelFormat = this.labelFormat.witClone; + return clone; + } +} + +/++ +A multiple-choice selection input control. ++/ +struct DialogInputSingleOption { + /++ + + +/ + TextComponent label; + + /++ + + +/ + WitList!(TextComponent) options; + + /++ + + +/ + uint initialIndex; + + void witFree() @nogc nothrow { + options.witFree; + } + + void witDrop() @nogc nothrow { + label.witDrop; + options.witDrop; + } + + DialogInputSingleOption witClone() const @nogc nothrow { + DialogInputSingleOption clone = void; + clone.label = this.label.witClone; + clone.options = this.options.witClone; + clone.initialIndex = this.initialIndex.witClone; + return clone; + } +} + +/++ +Represents an interactive input control in a dialog. ++/ +struct DialogInput { + mixin WitVariant!( + DialogInputBool, // bool_ + DialogInputText, // text + DialogInputNumberRange, // numberRange + DialogInputSingleOption, // singleOption + ); + +public: + enum Tag : ubyte { + /++ + A checkbox for true/false states. + +/ + bool_, + + /++ + A simple string input field. + +/ + text, + + /++ + A slider for numerical input within a range. + +/ + numberRange, + + /++ + A multiple-choice selection button. + +/ + singleOption, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + A checkbox for true/false states. + +/ + alias bool_ = _create!(Tag.bool_); + /// ditto + pragma(inline, true) bool isBool() const => _tag == Tag.bool_; + ///ditto + alias getBool = _get!(Tag.bool_); + + /++ + A simple string input field. + +/ + alias text = _create!(Tag.text); + /// ditto + pragma(inline, true) bool isText() const => _tag == Tag.text; + ///ditto + alias getText = _get!(Tag.text); + + /++ + A slider for numerical input within a range. + +/ + alias numberRange = _create!(Tag.numberRange); + /// ditto + pragma(inline, true) bool isNumberRange() const => _tag == Tag.numberRange; + ///ditto + alias getNumberRange = _get!(Tag.numberRange); + + /++ + A multiple-choice selection button. + +/ + alias singleOption = _create!(Tag.singleOption); + /// ditto + pragma(inline, true) bool isSingleOption() const => _tag == Tag.singleOption; + ///ditto + alias getSingleOption = _get!(Tag.singleOption); + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case text: _get!(Tag.text).witFree; break; + case numberRange: _get!(Tag.numberRange).witFree; break; + case singleOption: _get!(Tag.singleOption).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + switch (_tag) with (Tag) { + case bool_: _get!(Tag.bool_).witDrop; break; + case text: _get!(Tag.text).witDrop; break; + case numberRange: _get!(Tag.numberRange).witDrop; break; + case singleOption: _get!(Tag.singleOption).witDrop; break; + default: break; + } + } + + DialogInput witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.bool_: return _create!(Tag.bool_)(this._get!(Tag.bool_).witClone); break; + case Tag.text: return _create!(Tag.text)(this._get!(Tag.text).witClone); break; + case Tag.numberRange: return _create!(Tag.numberRange)(this._get!(Tag.numberRange).witClone); break; + case Tag.singleOption: return _create!(Tag.singleOption)(this._get!(Tag.singleOption).witClone); break; + } + } +} + +/++ +Represents a clickable button in a dialog. ++/ +struct ActionButton { + /++ + + +/ + TextComponent text; + + /++ + + +/ + Option!(TextComponent) tooltip; + + /++ + + +/ + Option!(uint) width; + + /++ + + +/ + Action action; + + void witFree() @nogc nothrow { + action.witFree; + } + + void witDrop() @nogc nothrow { + text.witDrop; + tooltip.witDrop; + } + + ActionButton witClone() const @nogc nothrow { + ActionButton clone = void; + clone.text = this.text.witClone; + clone.tooltip = this.tooltip.witClone; + clone.width = this.width.witClone; + clone.action = this.action.witClone; + return clone; + } +} + +/++ +The label for a link, which can be a built-in type or custom text. ++/ +struct LinkLabel { + mixin WitVariant!( + LinkType, // builtIn + TextComponent, // custom + ); + +public: + enum Tag : ubyte { + /++ + A built-in link type with a predefined icon/label. + +/ + builtIn, + + /++ + A custom text component label. + +/ + custom, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + A built-in link type with a predefined icon/label. + +/ + alias builtIn = _create!(Tag.builtIn); + /// ditto + pragma(inline, true) bool isBuiltIn() const => _tag == Tag.builtIn; + ///ditto + alias getBuiltIn = _get!(Tag.builtIn); + + /++ + A custom text component label. + +/ + alias custom = _create!(Tag.custom); + /// ditto + pragma(inline, true) bool isCustom() const => _tag == Tag.custom; + ///ditto + alias getCustom = _get!(Tag.custom); + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + switch (_tag) with (Tag) { + case custom: _get!(Tag.custom).witDrop; break; + default: break; + } + } + + LinkLabel witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.builtIn: return _create!(Tag.builtIn)(this._get!(Tag.builtIn).witClone); break; + case Tag.custom: return _create!(Tag.custom)(this._get!(Tag.custom).witClone); break; + } + } +} + +/++ +Represents a link displayed in a Java Edition dialog. ++/ +struct Link { + /++ + The label to display for the link. + +/ + LinkLabel label; + + /++ + The URL the link points to. + +/ + WitString url; + + void witFree() @nogc nothrow { + url.witFree; + } + + void witDrop() @nogc nothrow { + label.witDrop; + } + + Link witClone() const @nogc nothrow { + Link clone = void; + clone.label = this.label.witClone; + clone.url = this.url.witClone; + return clone; + } +} + +/++ +Represents a dialog shown to a Java Edition player. ++/ +struct Dialog { + /++ + The main title of the dialog. + +/ + TextComponent title; + + /++ + The layout type of the dialog. + +/ + DialogType type; + + /++ + A list of body elements to display in the main area. + +/ + WitList!(DialogBody) body_; + + /++ + A list of interactive input controls. + +/ + WitList!(DialogInput) inputs; + + /++ + A list of clickable buttons (for multi-action and other types). + +/ + WitList!(ActionButton) buttons; + + /++ + A list of links (primarily for server-links type). + +/ + WitList!(Link) links; + + /++ + What to do after the dialog is closed. + +/ + Option!(AfterAction) afterAction; + + /++ + Whether the player can exit the dialog using the Esc key. + +/ + bool canCloseWithEscape; + + /++ + The text shown on buttons that link to/open this dialog. + +/ + Option!(TextComponent) externalTitle; + + void witFree() @nogc nothrow { + body_.witFree; + inputs.witFree; + buttons.witFree; + links.witFree; + } + + void witDrop() @nogc nothrow { + title.witDrop; + body_.witDrop; + inputs.witDrop; + buttons.witDrop; + links.witDrop; + externalTitle.witDrop; + } + + Dialog witClone() const @nogc nothrow { + Dialog clone = void; + clone.title = this.title.witClone; + clone.type = this.type.witClone; + clone.body_ = this.body_.witClone; + clone.inputs = this.inputs.witClone; + clone.buttons = this.buttons.witClone; + clone.links = this.links.witClone; + clone.afterAction = this.afterAction.witClone; + clone.canCloseWithEscape = this.canCloseWithEscape.witClone; + clone.externalTitle = this.externalTitle.witClone; + return clone; + } +} diff --git a/src/wit/pumpkin/plugin/java_packets/common.d b/src/wit/pumpkin/plugin/java_packets/common.d new file mode 100644 index 0000000..dc46b1e --- /dev/null +++ b/src/wit/pumpkin/plugin/java_packets/common.d @@ -0,0 +1,15813 @@ +/++ + ++/ +module wit.pumpkin.plugin.java_packets.common; + + +import wit.common; + +static import wit.pumpkin.plugin.uuid.common; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias Uuid = wit.pumpkin.plugin.uuid.common.Uuid; + +/++ + ++/ +struct ConfigSClientInformationConfig { + /++ + + +/ + WitString locale; + + /++ + + +/ + ubyte viewDistance; + + /++ + + +/ + int chatMode; + + /++ + + +/ + bool chatColors; + + /++ + + +/ + ubyte skinParts; + + /++ + + +/ + int mainHand; + + /++ + + +/ + bool textFiltering; + + /++ + + +/ + bool serverListing; + + void witFree() @nogc nothrow { + locale.witFree; + } + + void witDrop() @nogc nothrow { + } + + ConfigSClientInformationConfig witClone() const @nogc nothrow { + ConfigSClientInformationConfig clone = void; + clone.locale = this.locale.witClone; + clone.viewDistance = this.viewDistance.witClone; + clone.chatMode = this.chatMode.witClone; + clone.chatColors = this.chatColors.witClone; + clone.skinParts = this.skinParts.witClone; + clone.mainHand = this.mainHand.witClone; + clone.textFiltering = this.textFiltering.witClone; + clone.serverListing = this.serverListing.witClone; + return clone; + } +} + +/++ + ++/ +struct ConfigSConfigCookieResponse { + /++ + + +/ + WitString key; + + /++ + + +/ + bool hasPayload; + + /++ + + +/ + Option!(WitList!(ubyte)) payload; + + void witFree() @nogc nothrow { + key.witFree; + payload.witFree; + } + + void witDrop() @nogc nothrow { + } + + ConfigSConfigCookieResponse witClone() const @nogc nothrow { + ConfigSConfigCookieResponse clone = void; + clone.key = this.key.witClone; + clone.hasPayload = this.hasPayload.witClone; + clone.payload = this.payload.witClone; + return clone; + } +} + +/++ + ++/ +struct ConfigSCustomClickAction { + /++ + + +/ + WitString actionId; + + /++ + + +/ + Option!(WitList!(ubyte)) payload; + + void witFree() @nogc nothrow { + actionId.witFree; + payload.witFree; + } + + void witDrop() @nogc nothrow { + } + + ConfigSCustomClickAction witClone() const @nogc nothrow { + ConfigSCustomClickAction clone = void; + clone.actionId = this.actionId.witClone; + clone.payload = this.payload.witClone; + return clone; + } +} + +/++ + ++/ +struct ConfigSKeepAlive { + /++ + + +/ + long keepAliveId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ConfigSKeepAlive witClone() const @nogc nothrow { + ConfigSKeepAlive clone = void; + clone.keepAliveId = this.keepAliveId.witClone; + return clone; + } +} + +/++ + ++/ +struct ConfigSKnownPacks { + /++ + + +/ + WitList!(WitString) knownPacks; + + void witFree() @nogc nothrow { + knownPacks.witFree; + } + + void witDrop() @nogc nothrow { + } + + ConfigSKnownPacks witClone() const @nogc nothrow { + ConfigSKnownPacks clone = void; + clone.knownPacks = this.knownPacks.witClone; + return clone; + } +} + +/++ + ++/ +struct ConfigSPluginMessage { + /++ + + +/ + WitString channel; + + /++ + + +/ + WitList!(ubyte) data; + + void witFree() @nogc nothrow { + channel.witFree; + data.witFree; + } + + void witDrop() @nogc nothrow { + } + + ConfigSPluginMessage witClone() const @nogc nothrow { + ConfigSPluginMessage clone = void; + clone.channel = this.channel.witClone; + clone.data = this.data.witClone; + return clone; + } +} + +/++ + ++/ +struct ConfigSConfigPong { + /++ + + +/ + int id; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ConfigSConfigPong witClone() const @nogc nothrow { + ConfigSConfigPong clone = void; + clone.id = this.id.witClone; + return clone; + } +} + +/++ + ++/ +struct ResourcePackResponseResult { + mixin WitVariant!( + void, // downloadSuccess + void, // downloadFail + void, // downloaded + void, // accepted + void, // declined + void, // invalidUrl + void, // reloadFailed + void, // discarded + int, // unknown + ); + +public: + enum Tag : ubyte { + /++ + + +/ + downloadSuccess, + + /++ + + +/ + downloadFail, + + /++ + + +/ + downloaded, + + /++ + + +/ + accepted, + + /++ + + +/ + declined, + + /++ + + +/ + invalidUrl, + + /++ + + +/ + reloadFailed, + + /++ + + +/ + discarded, + + /++ + + +/ + unknown, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias downloadSuccess = _create!(Tag.downloadSuccess); + /// ditto + pragma(inline, true) bool isDownloadSuccess() const => _tag == Tag.downloadSuccess; + + /++ + + +/ + alias downloadFail = _create!(Tag.downloadFail); + /// ditto + pragma(inline, true) bool isDownloadFail() const => _tag == Tag.downloadFail; + + /++ + + +/ + alias downloaded = _create!(Tag.downloaded); + /// ditto + pragma(inline, true) bool isDownloaded() const => _tag == Tag.downloaded; + + /++ + + +/ + alias accepted = _create!(Tag.accepted); + /// ditto + pragma(inline, true) bool isAccepted() const => _tag == Tag.accepted; + + /++ + + +/ + alias declined = _create!(Tag.declined); + /// ditto + pragma(inline, true) bool isDeclined() const => _tag == Tag.declined; + + /++ + + +/ + alias invalidUrl = _create!(Tag.invalidUrl); + /// ditto + pragma(inline, true) bool isInvalidUrl() const => _tag == Tag.invalidUrl; + + /++ + + +/ + alias reloadFailed = _create!(Tag.reloadFailed); + /// ditto + pragma(inline, true) bool isReloadFailed() const => _tag == Tag.reloadFailed; + + /++ + + +/ + alias discarded = _create!(Tag.discarded); + /// ditto + pragma(inline, true) bool isDiscarded() const => _tag == Tag.discarded; + + /++ + + +/ + alias unknown = _create!(Tag.unknown); + /// ditto + pragma(inline, true) bool isUnknown() const => _tag == Tag.unknown; + ///ditto + alias getUnknown = _get!(Tag.unknown); + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ResourcePackResponseResult witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.downloadSuccess: return _create!(Tag.downloadSuccess); break; + case Tag.downloadFail: return _create!(Tag.downloadFail); break; + case Tag.downloaded: return _create!(Tag.downloaded); break; + case Tag.accepted: return _create!(Tag.accepted); break; + case Tag.declined: return _create!(Tag.declined); break; + case Tag.invalidUrl: return _create!(Tag.invalidUrl); break; + case Tag.reloadFailed: return _create!(Tag.reloadFailed); break; + case Tag.discarded: return _create!(Tag.discarded); break; + case Tag.unknown: return _create!(Tag.unknown)(this._get!(Tag.unknown).witClone); break; + } + } +} + +/++ + ++/ +struct ConfigSConfigResourcePack { + /++ + + +/ + Uuid uuid; + + /++ + + +/ + int result; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ConfigSConfigResourcePack witClone() const @nogc nothrow { + ConfigSConfigResourcePack clone = void; + clone.uuid = this.uuid.witClone; + clone.result = this.result.witClone; + return clone; + } +} + +/++ + ++/ +struct LoginSLoginCookieResponse { + /++ + + +/ + WitString key; + + /++ + + +/ + Option!(WitList!(ubyte)) payload; + + void witFree() @nogc nothrow { + key.witFree; + payload.witFree; + } + + void witDrop() @nogc nothrow { + } + + LoginSLoginCookieResponse witClone() const @nogc nothrow { + LoginSLoginCookieResponse clone = void; + clone.key = this.key.witClone; + clone.payload = this.payload.witClone; + return clone; + } +} + +/++ + ++/ +struct SEncryptionResponse { + /++ + + +/ + WitList!(ubyte) sharedSecret; + + /++ + + +/ + WitList!(ubyte) verifyToken; + + void witFree() @nogc nothrow { + sharedSecret.witFree; + verifyToken.witFree; + } + + void witDrop() @nogc nothrow { + } + + SEncryptionResponse witClone() const @nogc nothrow { + SEncryptionResponse clone = void; + clone.sharedSecret = this.sharedSecret.witClone; + clone.verifyToken = this.verifyToken.witClone; + return clone; + } +} + +/++ + ++/ +struct LoginSLoginStart { + /++ + + +/ + WitString name; + + /++ + + +/ + Uuid uuid; + + void witFree() @nogc nothrow { + name.witFree; + } + + void witDrop() @nogc nothrow { + } + + LoginSLoginStart witClone() const @nogc nothrow { + LoginSLoginStart clone = void; + clone.name = this.name.witClone; + clone.uuid = this.uuid.witClone; + return clone; + } +} + +/++ + ++/ +struct LoginSLoginPluginResponse { + /++ + + +/ + int messageId; + + /++ + + +/ + Option!(WitList!(ubyte)) data; + + void witFree() @nogc nothrow { + data.witFree; + } + + void witDrop() @nogc nothrow { + } + + LoginSLoginPluginResponse witClone() const @nogc nothrow { + LoginSLoginPluginResponse clone = void; + clone.messageId = this.messageId.witClone; + clone.data = this.data.witClone; + return clone; + } +} + +/++ + ++/ +struct SAttack { + /++ + + +/ + int entityId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SAttack witClone() const @nogc nothrow { + SAttack clone = void; + clone.entityId = this.entityId.witClone; + return clone; + } +} + +/++ + ++/ +struct SBlockEntityTagQuery { + /++ + + +/ + int transactionId; + + /++ + + +/ + Tuple!(int, int, int) location; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SBlockEntityTagQuery witClone() const @nogc nothrow { + SBlockEntityTagQuery clone = void; + clone.transactionId = this.transactionId.witClone; + clone.location = this.location.witClone; + return clone; + } +} + +/++ + ++/ +struct SBundleItemSelected { + /++ + + +/ + int slotId; + + /++ + + +/ + int selectedItemIndex; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SBundleItemSelected witClone() const @nogc nothrow { + SBundleItemSelected clone = void; + clone.slotId = this.slotId.witClone; + clone.selectedItemIndex = this.selectedItemIndex.witClone; + return clone; + } +} + +/++ + ++/ +struct SChangeDifficulty { + /++ + + +/ + WitString difficulty; + + void witFree() @nogc nothrow { + difficulty.witFree; + } + + void witDrop() @nogc nothrow { + } + + SChangeDifficulty witClone() const @nogc nothrow { + SChangeDifficulty clone = void; + clone.difficulty = this.difficulty.witClone; + return clone; + } +} + +/++ + ++/ +struct SChangeGameMode { + /++ + + +/ + WitString gameMode; + + void witFree() @nogc nothrow { + gameMode.witFree; + } + + void witDrop() @nogc nothrow { + } + + SChangeGameMode witClone() const @nogc nothrow { + SChangeGameMode clone = void; + clone.gameMode = this.gameMode.witClone; + return clone; + } +} + +/++ + ++/ +struct SChatAck { + /++ + + +/ + int offset; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SChatAck witClone() const @nogc nothrow { + SChatAck clone = void; + clone.offset = this.offset.witClone; + return clone; + } +} + +/++ + ++/ +struct SChatCommand { + /++ + + +/ + WitString command; + + void witFree() @nogc nothrow { + command.witFree; + } + + void witDrop() @nogc nothrow { + } + + SChatCommand witClone() const @nogc nothrow { + SChatCommand clone = void; + clone.command = this.command.witClone; + return clone; + } +} + +/++ + ++/ +struct ArgumentSignature { + /++ + + +/ + WitString name; + + /++ + + +/ + WitList!(ubyte) signature; + + void witFree() @nogc nothrow { + name.witFree; + signature.witFree; + } + + void witDrop() @nogc nothrow { + } + + ArgumentSignature witClone() const @nogc nothrow { + ArgumentSignature clone = void; + clone.name = this.name.witClone; + clone.signature = this.signature.witClone; + return clone; + } +} + +/++ + ++/ +struct SChatCommandSigned { + /++ + + +/ + WitString command; + + /++ + + +/ + long timestamp; + + /++ + + +/ + long salt; + + /++ + + +/ + WitList!(ArgumentSignature) argumentSignatures; + + /++ + + +/ + int messageCount; + + /++ + + +/ + WitList!(ubyte) acknowledged; + + /++ + + +/ + ubyte checksum; + + void witFree() @nogc nothrow { + command.witFree; + argumentSignatures.witFree; + acknowledged.witFree; + } + + void witDrop() @nogc nothrow { + } + + SChatCommandSigned witClone() const @nogc nothrow { + SChatCommandSigned clone = void; + clone.command = this.command.witClone; + clone.timestamp = this.timestamp.witClone; + clone.salt = this.salt.witClone; + clone.argumentSignatures = this.argumentSignatures.witClone; + clone.messageCount = this.messageCount.witClone; + clone.acknowledged = this.acknowledged.witClone; + clone.checksum = this.checksum.witClone; + return clone; + } +} + +/++ + ++/ +struct SChatMessage { + /++ + + +/ + WitString message; + + /++ + + +/ + long timestamp; + + /++ + + +/ + long salt; + + /++ + + +/ + Option!(WitList!(ubyte)) signature; + + /++ + + +/ + int messageCount; + + /++ + + +/ + WitList!(ubyte) acknowledged; + + /++ + + +/ + ubyte checksum; + + void witFree() @nogc nothrow { + message.witFree; + signature.witFree; + acknowledged.witFree; + } + + void witDrop() @nogc nothrow { + } + + SChatMessage witClone() const @nogc nothrow { + SChatMessage clone = void; + clone.message = this.message.witClone; + clone.timestamp = this.timestamp.witClone; + clone.salt = this.salt.witClone; + clone.signature = this.signature.witClone; + clone.messageCount = this.messageCount.witClone; + clone.acknowledged = this.acknowledged.witClone; + clone.checksum = this.checksum.witClone; + return clone; + } +} + +/++ + ++/ +struct SChunkBatch { + /++ + + +/ + float chunksPerTick; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SChunkBatch witClone() const @nogc nothrow { + SChunkBatch clone = void; + clone.chunksPerTick = this.chunksPerTick.witClone; + return clone; + } +} + +/++ + ++/ +enum SlotActionType : ubyte { + /++ + + +/ + pickup, + + /++ + + +/ + quickMove, + + /++ + + +/ + swap, + + /++ + + +/ + clone, + + /++ + + +/ + throw_, + + /++ + + +/ + quickCraft, + + /++ + + +/ + pickupAll, +} +/++ + ++/ +struct SClickSlot { + /++ + + +/ + int syncId; + + /++ + + +/ + int revision; + + /++ + + +/ + int slot; + + /++ + + +/ + ubyte button; + + /++ + + +/ + SlotActionType mode; + + /++ + + +/ + int lengthOfArray; + + /++ + + +/ + WitList!(Tuple!(int, WitString)) arrayOfChangedSlots; + + /++ + + +/ + WitString carriedItem; + + void witFree() @nogc nothrow { + arrayOfChangedSlots.witFree; + carriedItem.witFree; + } + + void witDrop() @nogc nothrow { + } + + SClickSlot witClone() const @nogc nothrow { + SClickSlot clone = void; + clone.syncId = this.syncId.witClone; + clone.revision = this.revision.witClone; + clone.slot = this.slot.witClone; + clone.button = this.button.witClone; + clone.mode = this.mode.witClone; + clone.lengthOfArray = this.lengthOfArray.witClone; + clone.arrayOfChangedSlots = this.arrayOfChangedSlots.witClone; + clone.carriedItem = this.carriedItem.witClone; + return clone; + } +} + +/++ + ++/ +struct SClientCommand { + /++ + + +/ + int actionId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SClientCommand witClone() const @nogc nothrow { + SClientCommand clone = void; + clone.actionId = this.actionId.witClone; + return clone; + } +} + +/++ + ++/ +struct SClientInformationPlay { + /++ + + +/ + WitString locale; + + /++ + + +/ + ubyte viewDistance; + + /++ + + +/ + int chatMode; + + /++ + + +/ + bool chatColors; + + /++ + + +/ + ubyte skinParts; + + /++ + + +/ + int mainHand; + + /++ + + +/ + bool textFiltering; + + /++ + + +/ + bool serverListing; + + void witFree() @nogc nothrow { + locale.witFree; + } + + void witDrop() @nogc nothrow { + } + + SClientInformationPlay witClone() const @nogc nothrow { + SClientInformationPlay clone = void; + clone.locale = this.locale.witClone; + clone.viewDistance = this.viewDistance.witClone; + clone.chatMode = this.chatMode.witClone; + clone.chatColors = this.chatColors.witClone; + clone.skinParts = this.skinParts.witClone; + clone.mainHand = this.mainHand.witClone; + clone.textFiltering = this.textFiltering.witClone; + clone.serverListing = this.serverListing.witClone; + return clone; + } +} + +/++ + ++/ +struct SCloseContainer { + /++ + + +/ + int windowId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SCloseContainer witClone() const @nogc nothrow { + SCloseContainer clone = void; + clone.windowId = this.windowId.witClone; + return clone; + } +} + +/++ + ++/ +struct SCommandSuggestion { + /++ + + +/ + int id; + + /++ + + +/ + WitString command; + + void witFree() @nogc nothrow { + command.witFree; + } + + void witDrop() @nogc nothrow { + } + + SCommandSuggestion witClone() const @nogc nothrow { + SCommandSuggestion clone = void; + clone.id = this.id.witClone; + clone.command = this.command.witClone; + return clone; + } +} + +/++ + ++/ +struct SConfirmTeleport { + /++ + + +/ + int teleportId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SConfirmTeleport witClone() const @nogc nothrow { + SConfirmTeleport clone = void; + clone.teleportId = this.teleportId.witClone; + return clone; + } +} + +/++ + ++/ +struct SContainerButtonClick { + /++ + + +/ + int windowId; + + /++ + + +/ + int buttonId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SContainerButtonClick witClone() const @nogc nothrow { + SContainerButtonClick clone = void; + clone.windowId = this.windowId.witClone; + clone.buttonId = this.buttonId.witClone; + return clone; + } +} + +/++ + ++/ +struct SContainerSlotStateChanged { + /++ + + +/ + int slotId; + + /++ + + +/ + int containerId; + + /++ + + +/ + bool newState; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SContainerSlotStateChanged witClone() const @nogc nothrow { + SContainerSlotStateChanged clone = void; + clone.slotId = this.slotId.witClone; + clone.containerId = this.containerId.witClone; + clone.newState = this.newState.witClone; + return clone; + } +} + +/++ + ++/ +struct SCookieResponse { + /++ + + +/ + WitString key; + + /++ + + +/ + Option!(WitList!(ubyte)) payload; + + void witFree() @nogc nothrow { + key.witFree; + payload.witFree; + } + + void witDrop() @nogc nothrow { + } + + SCookieResponse witClone() const @nogc nothrow { + SCookieResponse clone = void; + clone.key = this.key.witClone; + clone.payload = this.payload.witClone; + return clone; + } +} + +/++ + ++/ +struct SCustomClickAction { + /++ + + +/ + WitString actionId; + + /++ + + +/ + Option!(WitList!(ubyte)) payload; + + void witFree() @nogc nothrow { + actionId.witFree; + payload.witFree; + } + + void witDrop() @nogc nothrow { + } + + SCustomClickAction witClone() const @nogc nothrow { + SCustomClickAction clone = void; + clone.actionId = this.actionId.witClone; + clone.payload = this.payload.witClone; + return clone; + } +} + +/++ + ++/ +struct SCustomPayload { + /++ + + +/ + WitString channel; + + /++ + + +/ + WitList!(ubyte) data; + + void witFree() @nogc nothrow { + channel.witFree; + data.witFree; + } + + void witDrop() @nogc nothrow { + } + + SCustomPayload witClone() const @nogc nothrow { + SCustomPayload clone = void; + clone.channel = this.channel.witClone; + clone.data = this.data.witClone; + return clone; + } +} + +/++ + ++/ +struct SDebugSampleSubscription { + /++ + + +/ + int sampleType; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SDebugSampleSubscription witClone() const @nogc nothrow { + SDebugSampleSubscription clone = void; + clone.sampleType = this.sampleType.witClone; + return clone; + } +} + +/++ + ++/ +struct SDebugSubscriptionRequest { + /++ + + +/ + int sampleType; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SDebugSubscriptionRequest witClone() const @nogc nothrow { + SDebugSubscriptionRequest clone = void; + clone.sampleType = this.sampleType.witClone; + return clone; + } +} + +/++ + ++/ +struct SEditBook { + /++ + + +/ + int slot; + + /++ + + +/ + WitList!(WitString) pages; + + /++ + + +/ + Option!(WitString) title; + + void witFree() @nogc nothrow { + pages.witFree; + title.witFree; + } + + void witDrop() @nogc nothrow { + } + + SEditBook witClone() const @nogc nothrow { + SEditBook clone = void; + clone.slot = this.slot.witClone; + clone.pages = this.pages.witClone; + clone.title = this.title.witClone; + return clone; + } +} + +/++ + ++/ +struct SEntityTagQuery { + /++ + + +/ + int transactionId; + + /++ + + +/ + int entityId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SEntityTagQuery witClone() const @nogc nothrow { + SEntityTagQuery clone = void; + clone.transactionId = this.transactionId.witClone; + clone.entityId = this.entityId.witClone; + return clone; + } +} + +/++ + ++/ +struct SInteract { + /++ + + +/ + int entityId; + + /++ + + +/ + int rType; + + /++ + + +/ + Option!(Tuple!(double, double, double)) targetPosition; + + /++ + + +/ + Option!(int) hand; + + /++ + + +/ + bool sneaking; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SInteract witClone() const @nogc nothrow { + SInteract clone = void; + clone.entityId = this.entityId.witClone; + clone.rType = this.rType.witClone; + clone.targetPosition = this.targetPosition.witClone; + clone.hand = this.hand.witClone; + clone.sneaking = this.sneaking.witClone; + return clone; + } +} + +/++ + ++/ +enum ActionType : ubyte { + /++ + + +/ + interact, + + /++ + + +/ + attack, + + /++ + + +/ + interactAt, +} +/++ + ++/ +struct SJigsawGenerate { + /++ + + +/ + Tuple!(int, int, int) pos; + + /++ + + +/ + int levels; + + /++ + + +/ + bool keepJigsaws; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SJigsawGenerate witClone() const @nogc nothrow { + SJigsawGenerate clone = void; + clone.pos = this.pos.witClone; + clone.levels = this.levels.witClone; + clone.keepJigsaws = this.keepJigsaws.witClone; + return clone; + } +} + +/++ + ++/ +struct SKeepAlive { + /++ + + +/ + long keepAliveId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SKeepAlive witClone() const @nogc nothrow { + SKeepAlive clone = void; + clone.keepAliveId = this.keepAliveId.witClone; + return clone; + } +} + +/++ + ++/ +struct SLockDifficulty { + /++ + + +/ + bool locked; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SLockDifficulty witClone() const @nogc nothrow { + SLockDifficulty clone = void; + clone.locked = this.locked.witClone; + return clone; + } +} + +/++ + ++/ +struct SMoveVehicle { + /++ + + +/ + double x; + + /++ + + +/ + double y; + + /++ + + +/ + double z; + + /++ + + +/ + float yaw; + + /++ + + +/ + float pitch; + + /++ + + +/ + bool onGround; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SMoveVehicle witClone() const @nogc nothrow { + SMoveVehicle clone = void; + clone.x = this.x.witClone; + clone.y = this.y.witClone; + clone.z = this.z.witClone; + clone.yaw = this.yaw.witClone; + clone.pitch = this.pitch.witClone; + clone.onGround = this.onGround.witClone; + return clone; + } +} + +/++ + ++/ +struct SPaddleBoat { + /++ + + +/ + bool leftPaddle; + + /++ + + +/ + bool rightPaddle; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SPaddleBoat witClone() const @nogc nothrow { + SPaddleBoat clone = void; + clone.leftPaddle = this.leftPaddle.witClone; + clone.rightPaddle = this.rightPaddle.witClone; + return clone; + } +} + +/++ + ++/ +struct SPickItemFromBlock { + /++ + + +/ + Tuple!(int, int, int) pos; + + /++ + + +/ + bool includeData; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SPickItemFromBlock witClone() const @nogc nothrow { + SPickItemFromBlock clone = void; + clone.pos = this.pos.witClone; + clone.includeData = this.includeData.witClone; + return clone; + } +} + +/++ + ++/ +struct SPickItemFromEntity { + /++ + + +/ + int id; + + /++ + + +/ + bool includeData; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SPickItemFromEntity witClone() const @nogc nothrow { + SPickItemFromEntity clone = void; + clone.id = this.id.witClone; + clone.includeData = this.includeData.witClone; + return clone; + } +} + +/++ + ++/ +struct SPlayPingRequest { + /++ + + +/ + long payload; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SPlayPingRequest witClone() const @nogc nothrow { + SPlayPingRequest clone = void; + clone.payload = this.payload.witClone; + return clone; + } +} + +/++ + ++/ +struct SPlaceRecipe { + /++ + + +/ + ubyte containerId; + + /++ + + +/ + int recipeDisplayId; + + /++ + + +/ + bool useMaxItems; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SPlaceRecipe witClone() const @nogc nothrow { + SPlaceRecipe clone = void; + clone.containerId = this.containerId.witClone; + clone.recipeDisplayId = this.recipeDisplayId.witClone; + clone.useMaxItems = this.useMaxItems.witClone; + return clone; + } +} + +/++ + ++/ +struct SPlayerAbilities { + /++ + + +/ + ubyte flags; + + /++ + + +/ + Option!(float) flySpeed; + + /++ + + +/ + Option!(float) walkSpeed; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SPlayerAbilities witClone() const @nogc nothrow { + SPlayerAbilities clone = void; + clone.flags = this.flags.witClone; + clone.flySpeed = this.flySpeed.witClone; + clone.walkSpeed = this.walkSpeed.witClone; + return clone; + } +} + +/++ + ++/ +struct SPlayerAction { + /++ + + +/ + int status; + + /++ + + +/ + Tuple!(int, int, int) position; + + /++ + + +/ + ubyte face; + + /++ + + +/ + int sequence; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SPlayerAction witClone() const @nogc nothrow { + SPlayerAction clone = void; + clone.status = this.status.witClone; + clone.position = this.position.witClone; + clone.face = this.face.witClone; + clone.sequence = this.sequence.witClone; + return clone; + } +} + +/++ + ++/ +enum Status : ubyte { + /++ + + +/ + startedDigging, + + /++ + + +/ + cancelledDigging, + + /++ + + +/ + finishedDigging, + + /++ + + +/ + dropItemStack, + + /++ + + +/ + dropItem, + + /++ + + +/ + releaseItemInUse, + + /++ + + +/ + swapItem, + + /++ + + +/ + spearJab, +} +/++ + ++/ +enum Action : ubyte { + /++ + + +/ + startSneaking, + + /++ + + +/ + stopSneaking, + + /++ + + +/ + leaveBed, + + /++ + + +/ + startSprinting, + + /++ + + +/ + stopSprinting, + + /++ + + +/ + startHorseJump, + + /++ + + +/ + stopHorseJump, + + /++ + + +/ + openVehicleInventory, + + /++ + + +/ + startFlyingElytra, +} +/++ + ++/ +struct SPlayerCommand { + /++ + + +/ + int entityId; + + /++ + + +/ + Action action; + + /++ + + +/ + int jumpBoost; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SPlayerCommand witClone() const @nogc nothrow { + SPlayerCommand clone = void; + clone.entityId = this.entityId.witClone; + clone.action = this.action.witClone; + clone.jumpBoost = this.jumpBoost.witClone; + return clone; + } +} + +/++ + ++/ +struct SSetPlayerGround { + /++ + + +/ + bool onGround; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SSetPlayerGround witClone() const @nogc nothrow { + SSetPlayerGround clone = void; + clone.onGround = this.onGround.witClone; + return clone; + } +} + +/++ + ++/ +struct SPlayerInput { + /++ + + +/ + ubyte input; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SPlayerInput witClone() const @nogc nothrow { + SPlayerInput clone = void; + clone.input = this.input.witClone; + return clone; + } +} + +/++ + ++/ +struct SPlayerPosition { + /++ + + +/ + Tuple!(double, double, double) position; + + /++ + + +/ + ubyte collision; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SPlayerPosition witClone() const @nogc nothrow { + SPlayerPosition clone = void; + clone.position = this.position.witClone; + clone.collision = this.collision.witClone; + return clone; + } +} + +/++ + ++/ +struct SPlayerPositionRotation { + /++ + + +/ + Tuple!(double, double, double) position; + + /++ + + +/ + float yaw; + + /++ + + +/ + float pitch; + + /++ + + +/ + ubyte collision; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SPlayerPositionRotation witClone() const @nogc nothrow { + SPlayerPositionRotation clone = void; + clone.position = this.position.witClone; + clone.yaw = this.yaw.witClone; + clone.pitch = this.pitch.witClone; + clone.collision = this.collision.witClone; + return clone; + } +} + +/++ + ++/ +struct SPlayerRotation { + /++ + + +/ + float yaw; + + /++ + + +/ + float pitch; + + /++ + + +/ + bool ground; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SPlayerRotation witClone() const @nogc nothrow { + SPlayerRotation clone = void; + clone.yaw = this.yaw.witClone; + clone.pitch = this.pitch.witClone; + clone.ground = this.ground.witClone; + return clone; + } +} + +/++ + ++/ +struct SPlayerSession { + /++ + + +/ + Uuid sessionId; + + /++ + + +/ + long expiresAt; + + /++ + + +/ + WitList!(ubyte) publicKey; + + /++ + + +/ + WitList!(ubyte) keySignature; + + void witFree() @nogc nothrow { + publicKey.witFree; + keySignature.witFree; + } + + void witDrop() @nogc nothrow { + } + + SPlayerSession witClone() const @nogc nothrow { + SPlayerSession clone = void; + clone.sessionId = this.sessionId.witClone; + clone.expiresAt = this.expiresAt.witClone; + clone.publicKey = this.publicKey.witClone; + clone.keySignature = this.keySignature.witClone; + return clone; + } +} + +/++ + ++/ +struct SPlayPong { + /++ + + +/ + int id; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SPlayPong witClone() const @nogc nothrow { + SPlayPong clone = void; + clone.id = this.id.witClone; + return clone; + } +} + +/++ + ++/ +struct SRecipeBookChangeSettings { + /++ + + +/ + int bookType; + + /++ + + +/ + bool isOpen; + + /++ + + +/ + bool isFiltering; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SRecipeBookChangeSettings witClone() const @nogc nothrow { + SRecipeBookChangeSettings clone = void; + clone.bookType = this.bookType.witClone; + clone.isOpen = this.isOpen.witClone; + clone.isFiltering = this.isFiltering.witClone; + return clone; + } +} + +/++ + ++/ +struct SRecipeBookSeenRecipe { + /++ + + +/ + int recipeDisplayId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SRecipeBookSeenRecipe witClone() const @nogc nothrow { + SRecipeBookSeenRecipe clone = void; + clone.recipeDisplayId = this.recipeDisplayId.witClone; + return clone; + } +} + +/++ + ++/ +struct SRenameItem { + /++ + + +/ + WitString itemName; + + void witFree() @nogc nothrow { + itemName.witFree; + } + + void witDrop() @nogc nothrow { + } + + SRenameItem witClone() const @nogc nothrow { + SRenameItem clone = void; + clone.itemName = this.itemName.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayResourcePackResult { + mixin WitVariant!( + void, // downloadSuccess + void, // declined + void, // downloadFail + void, // accepted + void, // downloaded + void, // invalidUrl + void, // reloadFailed + void, // discarded + int, // unknown + ); + +public: + enum Tag : ubyte { + /++ + + +/ + downloadSuccess, + + /++ + + +/ + declined, + + /++ + + +/ + downloadFail, + + /++ + + +/ + accepted, + + /++ + + +/ + downloaded, + + /++ + + +/ + invalidUrl, + + /++ + + +/ + reloadFailed, + + /++ + + +/ + discarded, + + /++ + + +/ + unknown, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias downloadSuccess = _create!(Tag.downloadSuccess); + /// ditto + pragma(inline, true) bool isDownloadSuccess() const => _tag == Tag.downloadSuccess; + + /++ + + +/ + alias declined = _create!(Tag.declined); + /// ditto + pragma(inline, true) bool isDeclined() const => _tag == Tag.declined; + + /++ + + +/ + alias downloadFail = _create!(Tag.downloadFail); + /// ditto + pragma(inline, true) bool isDownloadFail() const => _tag == Tag.downloadFail; + + /++ + + +/ + alias accepted = _create!(Tag.accepted); + /// ditto + pragma(inline, true) bool isAccepted() const => _tag == Tag.accepted; + + /++ + + +/ + alias downloaded = _create!(Tag.downloaded); + /// ditto + pragma(inline, true) bool isDownloaded() const => _tag == Tag.downloaded; + + /++ + + +/ + alias invalidUrl = _create!(Tag.invalidUrl); + /// ditto + pragma(inline, true) bool isInvalidUrl() const => _tag == Tag.invalidUrl; + + /++ + + +/ + alias reloadFailed = _create!(Tag.reloadFailed); + /// ditto + pragma(inline, true) bool isReloadFailed() const => _tag == Tag.reloadFailed; + + /++ + + +/ + alias discarded = _create!(Tag.discarded); + /// ditto + pragma(inline, true) bool isDiscarded() const => _tag == Tag.discarded; + + /++ + + +/ + alias unknown = _create!(Tag.unknown); + /// ditto + pragma(inline, true) bool isUnknown() const => _tag == Tag.unknown; + ///ditto + alias getUnknown = _get!(Tag.unknown); + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + PlayResourcePackResult witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.downloadSuccess: return _create!(Tag.downloadSuccess); break; + case Tag.declined: return _create!(Tag.declined); break; + case Tag.downloadFail: return _create!(Tag.downloadFail); break; + case Tag.accepted: return _create!(Tag.accepted); break; + case Tag.downloaded: return _create!(Tag.downloaded); break; + case Tag.invalidUrl: return _create!(Tag.invalidUrl); break; + case Tag.reloadFailed: return _create!(Tag.reloadFailed); break; + case Tag.discarded: return _create!(Tag.discarded); break; + case Tag.unknown: return _create!(Tag.unknown)(this._get!(Tag.unknown).witClone); break; + } + } +} + +/++ + ++/ +struct SPlayResourcePack { + /++ + + +/ + Uuid uuid; + + /++ + + +/ + int result; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SPlayResourcePack witClone() const @nogc nothrow { + SPlayResourcePack clone = void; + clone.uuid = this.uuid.witClone; + clone.result = this.result.witClone; + return clone; + } +} + +/++ + ++/ +struct SSeenAdvancement { + mixin WitVariant!( + WitString, // openTab + void, // closeTab + ); + +public: + enum Tag : ubyte { + /++ + + +/ + openTab, + + /++ + + +/ + closeTab, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias openTab = _create!(Tag.openTab); + /// ditto + pragma(inline, true) bool isOpenTab() const => _tag == Tag.openTab; + ///ditto + alias getOpenTab = _get!(Tag.openTab); + + /++ + + +/ + alias closeTab = _create!(Tag.closeTab); + /// ditto + pragma(inline, true) bool isCloseTab() const => _tag == Tag.closeTab; + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case openTab: _get!(Tag.openTab).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + } + + SSeenAdvancement witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.openTab: return _create!(Tag.openTab)(this._get!(Tag.openTab).witClone); break; + case Tag.closeTab: return _create!(Tag.closeTab); break; + } + } +} + +/++ + ++/ +struct SSelectTrade { + /++ + + +/ + int selectedSlot; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SSelectTrade witClone() const @nogc nothrow { + SSelectTrade clone = void; + clone.selectedSlot = this.selectedSlot.witClone; + return clone; + } +} + +/++ + ++/ +struct SSetBeacon { + /++ + + +/ + Option!(int) primaryEffect; + + /++ + + +/ + Option!(int) secondaryEffect; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SSetBeacon witClone() const @nogc nothrow { + SSetBeacon clone = void; + clone.primaryEffect = this.primaryEffect.witClone; + clone.secondaryEffect = this.secondaryEffect.witClone; + return clone; + } +} + +/++ + ++/ +struct SSetCommandBlock { + /++ + + +/ + Tuple!(int, int, int) pos; + + /++ + + +/ + WitString command; + + /++ + + +/ + int mode; + + /++ + + +/ + ubyte flags; + + void witFree() @nogc nothrow { + command.witFree; + } + + void witDrop() @nogc nothrow { + } + + SSetCommandBlock witClone() const @nogc nothrow { + SSetCommandBlock clone = void; + clone.pos = this.pos.witClone; + clone.command = this.command.witClone; + clone.mode = this.mode.witClone; + clone.flags = this.flags.witClone; + return clone; + } +} + +/++ + ++/ +enum CommandBlockMode : ubyte { + /++ + + +/ + chain, + + /++ + + +/ + repeating, + + /++ + + +/ + impulse, +} +/++ + ++/ +struct SSetCommandMinecart { + /++ + + +/ + int entityId; + + /++ + + +/ + WitString command; + + /++ + + +/ + bool trackOutput; + + void witFree() @nogc nothrow { + command.witFree; + } + + void witDrop() @nogc nothrow { + } + + SSetCommandMinecart witClone() const @nogc nothrow { + SSetCommandMinecart clone = void; + clone.entityId = this.entityId.witClone; + clone.command = this.command.witClone; + clone.trackOutput = this.trackOutput.witClone; + return clone; + } +} + +/++ + ++/ +struct SSetCreativeSlot { + /++ + + +/ + int slot; + + /++ + + +/ + WitString clickedItem; + + void witFree() @nogc nothrow { + clickedItem.witFree; + } + + void witDrop() @nogc nothrow { + } + + SSetCreativeSlot witClone() const @nogc nothrow { + SSetCreativeSlot clone = void; + clone.slot = this.slot.witClone; + clone.clickedItem = this.clickedItem.witClone; + return clone; + } +} + +/++ + ++/ +struct GameRuleEntry { + /++ + + +/ + WitString gameRuleKey; + + /++ + + +/ + WitString value; + + void witFree() @nogc nothrow { + gameRuleKey.witFree; + value.witFree; + } + + void witDrop() @nogc nothrow { + } + + GameRuleEntry witClone() const @nogc nothrow { + GameRuleEntry clone = void; + clone.gameRuleKey = this.gameRuleKey.witClone; + clone.value = this.value.witClone; + return clone; + } +} + +/++ + ++/ +struct SSetGameRule { + /++ + + +/ + WitList!(GameRuleEntry) entries; + + void witFree() @nogc nothrow { + entries.witFree; + } + + void witDrop() @nogc nothrow { + } + + SSetGameRule witClone() const @nogc nothrow { + SSetGameRule clone = void; + clone.entries = this.entries.witClone; + return clone; + } +} + +/++ + ++/ +struct SSetHeldItem { + /++ + + +/ + int slot; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SSetHeldItem witClone() const @nogc nothrow { + SSetHeldItem clone = void; + clone.slot = this.slot.witClone; + return clone; + } +} + +/++ + ++/ +struct SSetJigsawBlock { + /++ + + +/ + Tuple!(int, int, int) pos; + + /++ + + +/ + WitString name; + + /++ + + +/ + WitString target; + + /++ + + +/ + WitString pool; + + /++ + + +/ + WitString finalState; + + /++ + + +/ + WitString joint; + + /++ + + +/ + int selectionPriority; + + /++ + + +/ + int placementPriority; + + void witFree() @nogc nothrow { + name.witFree; + target.witFree; + pool.witFree; + finalState.witFree; + joint.witFree; + } + + void witDrop() @nogc nothrow { + } + + SSetJigsawBlock witClone() const @nogc nothrow { + SSetJigsawBlock clone = void; + clone.pos = this.pos.witClone; + clone.name = this.name.witClone; + clone.target = this.target.witClone; + clone.pool = this.pool.witClone; + clone.finalState = this.finalState.witClone; + clone.joint = this.joint.witClone; + clone.selectionPriority = this.selectionPriority.witClone; + clone.placementPriority = this.placementPriority.witClone; + return clone; + } +} + +/++ + ++/ +struct SSetStructureBlock { + /++ + + +/ + Tuple!(int, int, int) location; + + /++ + + +/ + int action; + + /++ + + +/ + int mode; + + /++ + + +/ + WitString name; + + /++ + + +/ + ubyte offsetX; + + /++ + + +/ + ubyte offsetY; + + /++ + + +/ + ubyte offsetZ; + + /++ + + +/ + ubyte sizeX; + + /++ + + +/ + ubyte sizeY; + + /++ + + +/ + ubyte sizeZ; + + /++ + + +/ + int mirror; + + /++ + + +/ + int rotation; + + /++ + + +/ + WitString metadata; + + /++ + + +/ + float integrity; + + /++ + + +/ + long seed; + + /++ + + +/ + ubyte flags; + + void witFree() @nogc nothrow { + name.witFree; + metadata.witFree; + } + + void witDrop() @nogc nothrow { + } + + SSetStructureBlock witClone() const @nogc nothrow { + SSetStructureBlock clone = void; + clone.location = this.location.witClone; + clone.action = this.action.witClone; + clone.mode = this.mode.witClone; + clone.name = this.name.witClone; + clone.offsetX = this.offsetX.witClone; + clone.offsetY = this.offsetY.witClone; + clone.offsetZ = this.offsetZ.witClone; + clone.sizeX = this.sizeX.witClone; + clone.sizeY = this.sizeY.witClone; + clone.sizeZ = this.sizeZ.witClone; + clone.mirror = this.mirror.witClone; + clone.rotation = this.rotation.witClone; + clone.metadata = this.metadata.witClone; + clone.integrity = this.integrity.witClone; + clone.seed = this.seed.witClone; + clone.flags = this.flags.witClone; + return clone; + } +} + +/++ + ++/ +enum TestBlockMode : ubyte { + /++ + + +/ + start, + + /++ + + +/ + log, + + /++ + + +/ + fail, + + /++ + + +/ + accept, +} +/++ + ++/ +struct SSetTestBlock { + /++ + + +/ + Tuple!(int, int, int) position; + + /++ + + +/ + TestBlockMode mode; + + /++ + + +/ + WitString message; + + void witFree() @nogc nothrow { + message.witFree; + } + + void witDrop() @nogc nothrow { + } + + SSetTestBlock witClone() const @nogc nothrow { + SSetTestBlock clone = void; + clone.position = this.position.witClone; + clone.mode = this.mode.witClone; + clone.message = this.message.witClone; + return clone; + } +} + +/++ + ++/ +struct SSpectateEntity { + /++ + + +/ + Uuid target; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SSpectateEntity witClone() const @nogc nothrow { + SSpectateEntity clone = void; + clone.target = this.target.witClone; + return clone; + } +} + +/++ + ++/ +struct SSwingArm { + /++ + + +/ + int hand; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SSwingArm witClone() const @nogc nothrow { + SSwingArm clone = void; + clone.hand = this.hand.witClone; + return clone; + } +} + +/++ + ++/ +struct STeleportToEntity { + /++ + + +/ + Uuid target; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + STeleportToEntity witClone() const @nogc nothrow { + STeleportToEntity clone = void; + clone.target = this.target.witClone; + return clone; + } +} + +/++ + ++/ +enum TestInstanceBlockAction : ubyte { + /++ + + +/ + init, + + /++ + + +/ + query, + + /++ + + +/ + set, + + /++ + + +/ + reset, + + /++ + + +/ + save, + + /++ + + +/ + export_, + + /++ + + +/ + run, +} +/++ + ++/ +struct VarIntVector3 { + /++ + + +/ + int x; + + /++ + + +/ + int y; + + /++ + + +/ + int z; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + VarIntVector3 witClone() const @nogc nothrow { + VarIntVector3 clone = void; + clone.x = this.x.witClone; + clone.y = this.y.witClone; + clone.z = this.z.witClone; + return clone; + } +} + +/++ + ++/ +enum TestInstanceBlockStatus : ubyte { + /++ + + +/ + cleared, + + /++ + + +/ + running, + + /++ + + +/ + success, + + /++ + + +/ + failed, +} +/++ + ++/ +struct TestInstanceBlockData { + /++ + + +/ + Option!(WitString) test; + + /++ + + +/ + VarIntVector3 size; + + /++ + + +/ + WitString rotation; + + /++ + + +/ + bool ignoreEntities; + + /++ + + +/ + TestInstanceBlockStatus status; + + /++ + + +/ + Option!(WitString) errorMessage; + + void witFree() @nogc nothrow { + test.witFree; + rotation.witFree; + errorMessage.witFree; + } + + void witDrop() @nogc nothrow { + } + + TestInstanceBlockData witClone() const @nogc nothrow { + TestInstanceBlockData clone = void; + clone.test = this.test.witClone; + clone.size = this.size.witClone; + clone.rotation = this.rotation.witClone; + clone.ignoreEntities = this.ignoreEntities.witClone; + clone.status = this.status.witClone; + clone.errorMessage = this.errorMessage.witClone; + return clone; + } +} + +/++ + ++/ +struct STestInstanceBlockAction { + /++ + + +/ + Tuple!(int, int, int) pos; + + /++ + + +/ + TestInstanceBlockAction action; + + /++ + + +/ + TestInstanceBlockData data; + + void witFree() @nogc nothrow { + data.witFree; + } + + void witDrop() @nogc nothrow { + } + + STestInstanceBlockAction witClone() const @nogc nothrow { + STestInstanceBlockAction clone = void; + clone.pos = this.pos.witClone; + clone.action = this.action.witClone; + clone.data = this.data.witClone; + return clone; + } +} + +/++ + ++/ +struct SUpdateSign { + /++ + + +/ + Tuple!(int, int, int) location; + + /++ + + +/ + bool isFrontText; + + /++ + + +/ + WitString line1; + + /++ + + +/ + WitString line2; + + /++ + + +/ + WitString line3; + + /++ + + +/ + WitString line4; + + void witFree() @nogc nothrow { + line1.witFree; + line2.witFree; + line3.witFree; + line4.witFree; + } + + void witDrop() @nogc nothrow { + } + + SUpdateSign witClone() const @nogc nothrow { + SUpdateSign clone = void; + clone.location = this.location.witClone; + clone.isFrontText = this.isFrontText.witClone; + clone.line1 = this.line1.witClone; + clone.line2 = this.line2.witClone; + clone.line3 = this.line3.witClone; + clone.line4 = this.line4.witClone; + return clone; + } +} + +/++ + ++/ +struct SUseItem { + /++ + + +/ + int hand; + + /++ + + +/ + int sequence; + + /++ + + +/ + float yaw; + + /++ + + +/ + float pitch; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SUseItem witClone() const @nogc nothrow { + SUseItem clone = void; + clone.hand = this.hand.witClone; + clone.sequence = this.sequence.witClone; + clone.yaw = this.yaw.witClone; + clone.pitch = this.pitch.witClone; + return clone; + } +} + +/++ + ++/ +struct SUseItemOn { + /++ + + +/ + int hand; + + /++ + + +/ + Tuple!(int, int, int) position; + + /++ + + +/ + int face; + + /++ + + +/ + Tuple!(double, double, double) cursorPos; + + /++ + + +/ + bool insideBlock; + + /++ + + +/ + bool isAgainstWorldBorder; + + /++ + + +/ + int sequence; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SUseItemOn witClone() const @nogc nothrow { + SUseItemOn clone = void; + clone.hand = this.hand.witClone; + clone.position = this.position.witClone; + clone.face = this.face.witClone; + clone.cursorPos = this.cursorPos.witClone; + clone.insideBlock = this.insideBlock.witClone; + clone.isAgainstWorldBorder = this.isAgainstWorldBorder.witClone; + clone.sequence = this.sequence.witClone; + return clone; + } +} + +/++ + ++/ +struct StatusSStatusPingRequest { + /++ + + +/ + long payload; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + StatusSStatusPingRequest witClone() const @nogc nothrow { + StatusSStatusPingRequest clone = void; + clone.payload = this.payload.witClone; + return clone; + } +} + +/++ + ++/ +struct ConfigCConfigAddResourcePack { + /++ + + +/ + Uuid uuid; + + /++ + + +/ + WitString url; + + /++ + + +/ + WitString hash; + + /++ + + +/ + bool forced; + + /++ + + +/ + Option!(WitString) promptMessage; + + void witFree() @nogc nothrow { + url.witFree; + hash.witFree; + promptMessage.witFree; + } + + void witDrop() @nogc nothrow { + } + + ConfigCConfigAddResourcePack witClone() const @nogc nothrow { + ConfigCConfigAddResourcePack clone = void; + clone.uuid = this.uuid.witClone; + clone.url = this.url.witClone; + clone.hash = this.hash.witClone; + clone.forced = this.forced.witClone; + clone.promptMessage = this.promptMessage.witClone; + return clone; + } +} + +/++ + ++/ +struct ConfigCCodeOfConduct { + /++ + + +/ + WitString codeOfConduct; + + void witFree() @nogc nothrow { + codeOfConduct.witFree; + } + + void witDrop() @nogc nothrow { + } + + ConfigCCodeOfConduct witClone() const @nogc nothrow { + ConfigCCodeOfConduct clone = void; + clone.codeOfConduct = this.codeOfConduct.witClone; + return clone; + } +} + +/++ + ++/ +struct ConfigCConfigDisconnect { + /++ + + +/ + WitString reason; + + void witFree() @nogc nothrow { + reason.witFree; + } + + void witDrop() @nogc nothrow { + } + + ConfigCConfigDisconnect witClone() const @nogc nothrow { + ConfigCConfigDisconnect clone = void; + clone.reason = this.reason.witClone; + return clone; + } +} + +/++ + ++/ +struct ConfigCCookieRequest { + /++ + + +/ + WitString key; + + void witFree() @nogc nothrow { + key.witFree; + } + + void witDrop() @nogc nothrow { + } + + ConfigCCookieRequest witClone() const @nogc nothrow { + ConfigCCookieRequest clone = void; + clone.key = this.key.witClone; + return clone; + } +} + +/++ + ++/ +struct ConfigCConfigCustomReportDetails { + /++ + + +/ + WitList!(Tuple!(WitString, WitString)) details; + + void witFree() @nogc nothrow { + details.witFree; + } + + void witDrop() @nogc nothrow { + } + + ConfigCConfigCustomReportDetails witClone() const @nogc nothrow { + ConfigCConfigCustomReportDetails clone = void; + clone.details = this.details.witClone; + return clone; + } +} + +/++ + ++/ +struct ConfigCFeatureFlags { + /++ + + +/ + WitList!(WitString) features; + + void witFree() @nogc nothrow { + features.witFree; + } + + void witDrop() @nogc nothrow { + } + + ConfigCFeatureFlags witClone() const @nogc nothrow { + ConfigCFeatureFlags clone = void; + clone.features = this.features.witClone; + return clone; + } +} + +/++ + ++/ +struct ConfigCKnownPacks { + /++ + + +/ + WitList!(WitString) knownPacks; + + void witFree() @nogc nothrow { + knownPacks.witFree; + } + + void witDrop() @nogc nothrow { + } + + ConfigCKnownPacks witClone() const @nogc nothrow { + ConfigCKnownPacks clone = void; + clone.knownPacks = this.knownPacks.witClone; + return clone; + } +} + +/++ + ++/ +struct ConfigCConfigPing { + /++ + + +/ + int id; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ConfigCConfigPing witClone() const @nogc nothrow { + ConfigCConfigPing clone = void; + clone.id = this.id.witClone; + return clone; + } +} + +/++ + ++/ +struct ConfigCPluginMessage { + /++ + + +/ + WitString channel; + + /++ + + +/ + WitList!(ubyte) data; + + void witFree() @nogc nothrow { + channel.witFree; + data.witFree; + } + + void witDrop() @nogc nothrow { + } + + ConfigCPluginMessage witClone() const @nogc nothrow { + ConfigCPluginMessage clone = void; + clone.channel = this.channel.witClone; + clone.data = this.data.witClone; + return clone; + } +} + +/++ + ++/ +struct ConfigCRegistryData { + /++ + + +/ + WitString registryId; + + /++ + + +/ + WitList!(WitString) entries; + + void witFree() @nogc nothrow { + registryId.witFree; + entries.witFree; + } + + void witDrop() @nogc nothrow { + } + + ConfigCRegistryData witClone() const @nogc nothrow { + ConfigCRegistryData clone = void; + clone.registryId = this.registryId.witClone; + clone.entries = this.entries.witClone; + return clone; + } +} + +/++ + ++/ +struct ConfigCConfigRemoveResourcePack { + /++ + + +/ + Option!(Uuid) uuid; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ConfigCConfigRemoveResourcePack witClone() const @nogc nothrow { + ConfigCConfigRemoveResourcePack clone = void; + clone.uuid = this.uuid.witClone; + return clone; + } +} + +/++ + ++/ +struct ConfigCConfigServerLinks { + /++ + + +/ + WitList!(WitString) links; + + void witFree() @nogc nothrow { + links.witFree; + } + + void witDrop() @nogc nothrow { + } + + ConfigCConfigServerLinks witClone() const @nogc nothrow { + ConfigCConfigServerLinks clone = void; + clone.links = this.links.witClone; + return clone; + } +} + +/++ + ++/ +struct ConfigCConfigShowDialog { + /++ + + +/ + WitString dialog; + + void witFree() @nogc nothrow { + dialog.witFree; + } + + void witDrop() @nogc nothrow { + } + + ConfigCConfigShowDialog witClone() const @nogc nothrow { + ConfigCConfigShowDialog clone = void; + clone.dialog = this.dialog.witClone; + return clone; + } +} + +/++ + ++/ +struct ConfigCStoreCookie { + /++ + + +/ + WitString key; + + /++ + + +/ + WitList!(ubyte) payload; + + void witFree() @nogc nothrow { + key.witFree; + payload.witFree; + } + + void witDrop() @nogc nothrow { + } + + ConfigCStoreCookie witClone() const @nogc nothrow { + ConfigCStoreCookie clone = void; + clone.key = this.key.witClone; + clone.payload = this.payload.witClone; + return clone; + } +} + +/++ + ++/ +struct ConfigCTransfer { + /++ + + +/ + WitString host; + + /++ + + +/ + int port; + + void witFree() @nogc nothrow { + host.witFree; + } + + void witDrop() @nogc nothrow { + } + + ConfigCTransfer witClone() const @nogc nothrow { + ConfigCTransfer clone = void; + clone.host = this.host.witClone; + clone.port = this.port.witClone; + return clone; + } +} + +/++ + ++/ +struct ConfigCUpdateTags { + /++ + + +/ + WitList!(WitString) tags; + + void witFree() @nogc nothrow { + tags.witFree; + } + + void witDrop() @nogc nothrow { + } + + ConfigCUpdateTags witClone() const @nogc nothrow { + ConfigCUpdateTags clone = void; + clone.tags = this.tags.witClone; + return clone; + } +} + +/++ + ++/ +struct LoginCLoginCookieRequest { + /++ + + +/ + WitString key; + + void witFree() @nogc nothrow { + key.witFree; + } + + void witDrop() @nogc nothrow { + } + + LoginCLoginCookieRequest witClone() const @nogc nothrow { + LoginCLoginCookieRequest clone = void; + clone.key = this.key.witClone; + return clone; + } +} + +/++ + ++/ +struct CEncryptionRequest { + /++ + + +/ + WitString serverId; + + /++ + + +/ + WitList!(ubyte) publicKey; + + /++ + + +/ + WitList!(ubyte) verifyToken; + + /++ + + +/ + bool shouldAuthenticate; + + void witFree() @nogc nothrow { + serverId.witFree; + publicKey.witFree; + verifyToken.witFree; + } + + void witDrop() @nogc nothrow { + } + + CEncryptionRequest witClone() const @nogc nothrow { + CEncryptionRequest clone = void; + clone.serverId = this.serverId.witClone; + clone.publicKey = this.publicKey.witClone; + clone.verifyToken = this.verifyToken.witClone; + clone.shouldAuthenticate = this.shouldAuthenticate.witClone; + return clone; + } +} + +/++ + ++/ +struct LoginCLoginDisconnect { + /++ + + +/ + WitString jsonReason; + + void witFree() @nogc nothrow { + jsonReason.witFree; + } + + void witDrop() @nogc nothrow { + } + + LoginCLoginDisconnect witClone() const @nogc nothrow { + LoginCLoginDisconnect clone = void; + clone.jsonReason = this.jsonReason.witClone; + return clone; + } +} + +/++ + ++/ +struct LoginCLoginPluginRequest { + /++ + + +/ + int messageId; + + /++ + + +/ + WitString channel; + + /++ + + +/ + WitList!(ubyte) data; + + void witFree() @nogc nothrow { + channel.witFree; + data.witFree; + } + + void witDrop() @nogc nothrow { + } + + LoginCLoginPluginRequest witClone() const @nogc nothrow { + LoginCLoginPluginRequest clone = void; + clone.messageId = this.messageId.witClone; + clone.channel = this.channel.witClone; + clone.data = this.data.witClone; + return clone; + } +} + +/++ + ++/ +struct LoginCSetCompression { + /++ + + +/ + int threshold; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + LoginCSetCompression witClone() const @nogc nothrow { + LoginCSetCompression clone = void; + clone.threshold = this.threshold.witClone; + return clone; + } +} + +/++ + ++/ +struct CAcknowledgeBlockChange { + /++ + + +/ + int sequenceId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CAcknowledgeBlockChange witClone() const @nogc nothrow { + CAcknowledgeBlockChange clone = void; + clone.sequenceId = this.sequenceId.witClone; + return clone; + } +} + +/++ + ++/ +struct CActionBar { + /++ + + +/ + WitString actionBar; + + void witFree() @nogc nothrow { + actionBar.witFree; + } + + void witDrop() @nogc nothrow { + } + + CActionBar witClone() const @nogc nothrow { + CActionBar clone = void; + clone.actionBar = this.actionBar.witClone; + return clone; + } +} + +/++ + ++/ +struct CAddResourcePack { + /++ + + +/ + Uuid uuid; + + /++ + + +/ + WitString url; + + /++ + + +/ + WitString hash; + + /++ + + +/ + bool forced; + + /++ + + +/ + Option!(WitString) promptMessage; + + void witFree() @nogc nothrow { + url.witFree; + hash.witFree; + promptMessage.witFree; + } + + void witDrop() @nogc nothrow { + } + + CAddResourcePack witClone() const @nogc nothrow { + CAddResourcePack clone = void; + clone.uuid = this.uuid.witClone; + clone.url = this.url.witClone; + clone.hash = this.hash.witClone; + clone.forced = this.forced.witClone; + clone.promptMessage = this.promptMessage.witClone; + return clone; + } +} + +/++ + ++/ +struct Statistic { + /++ + + +/ + int categoryId; + + /++ + + +/ + int statisticId; + + /++ + + +/ + int value; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + Statistic witClone() const @nogc nothrow { + Statistic clone = void; + clone.categoryId = this.categoryId.witClone; + clone.statisticId = this.statisticId.witClone; + clone.value = this.value.witClone; + return clone; + } +} + +/++ + ++/ +struct CAwardStats { + /++ + + +/ + WitList!(Statistic) stats; + + void witFree() @nogc nothrow { + stats.witFree; + } + + void witDrop() @nogc nothrow { + } + + CAwardStats witClone() const @nogc nothrow { + CAwardStats clone = void; + clone.stats = this.stats.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetBlockDestroyStage { + /++ + + +/ + int entityId; + + /++ + + +/ + Tuple!(int, int, int) location; + + /++ + + +/ + ubyte destroyStage; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CSetBlockDestroyStage witClone() const @nogc nothrow { + CSetBlockDestroyStage clone = void; + clone.entityId = this.entityId.witClone; + clone.location = this.location.witClone; + clone.destroyStage = this.destroyStage.witClone; + return clone; + } +} + +/++ + ++/ +struct CBlockEntityData { + /++ + + +/ + Tuple!(int, int, int) location; + + /++ + + +/ + int rType; + + /++ + + +/ + WitList!(ubyte) nbtData; + + void witFree() @nogc nothrow { + nbtData.witFree; + } + + void witDrop() @nogc nothrow { + } + + CBlockEntityData witClone() const @nogc nothrow { + CBlockEntityData clone = void; + clone.location = this.location.witClone; + clone.rType = this.rType.witClone; + clone.nbtData = this.nbtData.witClone; + return clone; + } +} + +/++ + ++/ +struct CBlockEvent { + /++ + + +/ + Tuple!(int, int, int) location; + + /++ + + +/ + ubyte actionId; + + /++ + + +/ + ubyte actionParameter; + + /++ + + +/ + int blockType; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CBlockEvent witClone() const @nogc nothrow { + CBlockEvent clone = void; + clone.location = this.location.witClone; + clone.actionId = this.actionId.witClone; + clone.actionParameter = this.actionParameter.witClone; + clone.blockType = this.blockType.witClone; + return clone; + } +} + +/++ + ++/ +struct CBlockUpdate { + /++ + + +/ + Tuple!(int, int, int) location; + + /++ + + +/ + int stateId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CBlockUpdate witClone() const @nogc nothrow { + CBlockUpdate clone = void; + clone.location = this.location.witClone; + clone.stateId = this.stateId.witClone; + return clone; + } +} + +/++ + ++/ +struct BosseventActionAdd { + /++ + + +/ + WitString title; + + /++ + + +/ + float health; + + /++ + + +/ + int color; + + /++ + + +/ + int division; + + /++ + + +/ + ubyte flags; + + void witFree() @nogc nothrow { + title.witFree; + } + + void witDrop() @nogc nothrow { + } + + BosseventActionAdd witClone() const @nogc nothrow { + BosseventActionAdd clone = void; + clone.title = this.title.witClone; + clone.health = this.health.witClone; + clone.color = this.color.witClone; + clone.division = this.division.witClone; + clone.flags = this.flags.witClone; + return clone; + } +} + +/++ + ++/ +struct BosseventActionUpdateStyle { + /++ + + +/ + int color; + + /++ + + +/ + int dividers; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + BosseventActionUpdateStyle witClone() const @nogc nothrow { + BosseventActionUpdateStyle clone = void; + clone.color = this.color.witClone; + clone.dividers = this.dividers.witClone; + return clone; + } +} + +/++ + ++/ +struct BosseventAction { + mixin WitVariant!( + BosseventActionAdd, // add + void, // remove + float, // updateHealth + WitString, // updateTile + BosseventActionUpdateStyle, // updateStyle + ubyte, // updateFlags + ); + +public: + enum Tag : ubyte { + /++ + + +/ + add, + + /++ + + +/ + remove, + + /++ + + +/ + updateHealth, + + /++ + + +/ + updateTile, + + /++ + + +/ + updateStyle, + + /++ + + +/ + updateFlags, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias add = _create!(Tag.add); + /// ditto + pragma(inline, true) bool isAdd() const => _tag == Tag.add; + ///ditto + alias getAdd = _get!(Tag.add); + + /++ + + +/ + alias remove = _create!(Tag.remove); + /// ditto + pragma(inline, true) bool isRemove() const => _tag == Tag.remove; + + /++ + + +/ + alias updateHealth = _create!(Tag.updateHealth); + /// ditto + pragma(inline, true) bool isUpdateHealth() const => _tag == Tag.updateHealth; + ///ditto + alias getUpdateHealth = _get!(Tag.updateHealth); + + /++ + + +/ + alias updateTile = _create!(Tag.updateTile); + /// ditto + pragma(inline, true) bool isUpdateTile() const => _tag == Tag.updateTile; + ///ditto + alias getUpdateTile = _get!(Tag.updateTile); + + /++ + + +/ + alias updateStyle = _create!(Tag.updateStyle); + /// ditto + pragma(inline, true) bool isUpdateStyle() const => _tag == Tag.updateStyle; + ///ditto + alias getUpdateStyle = _get!(Tag.updateStyle); + + /++ + + +/ + alias updateFlags = _create!(Tag.updateFlags); + /// ditto + pragma(inline, true) bool isUpdateFlags() const => _tag == Tag.updateFlags; + ///ditto + alias getUpdateFlags = _get!(Tag.updateFlags); + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case add: _get!(Tag.add).witFree; break; + case updateTile: _get!(Tag.updateTile).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + } + + BosseventAction witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.add: return _create!(Tag.add)(this._get!(Tag.add).witClone); break; + case Tag.remove: return _create!(Tag.remove); break; + case Tag.updateHealth: return _create!(Tag.updateHealth)(this._get!(Tag.updateHealth).witClone); break; + case Tag.updateTile: return _create!(Tag.updateTile)(this._get!(Tag.updateTile).witClone); break; + case Tag.updateStyle: return _create!(Tag.updateStyle)(this._get!(Tag.updateStyle).witClone); break; + case Tag.updateFlags: return _create!(Tag.updateFlags)(this._get!(Tag.updateFlags).witClone); break; + } + } +} + +/++ + ++/ +struct CBossEvent { + /++ + + +/ + Uuid uuid; + + /++ + + +/ + BosseventAction action; + + void witFree() @nogc nothrow { + action.witFree; + } + + void witDrop() @nogc nothrow { + } + + CBossEvent witClone() const @nogc nothrow { + CBossEvent clone = void; + clone.uuid = this.uuid.witClone; + clone.action = this.action.witClone; + return clone; + } +} + +/++ + ++/ +struct CCenterChunk { + /++ + + +/ + int chunkX; + + /++ + + +/ + int chunkZ; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CCenterChunk witClone() const @nogc nothrow { + CCenterChunk clone = void; + clone.chunkX = this.chunkX.witClone; + clone.chunkZ = this.chunkZ.witClone; + return clone; + } +} + +/++ + ++/ +struct CChangeDifficulty { + /++ + + +/ + ubyte difficulty; + + /++ + + +/ + bool locked; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CChangeDifficulty witClone() const @nogc nothrow { + CChangeDifficulty clone = void; + clone.difficulty = this.difficulty.witClone; + clone.locked = this.locked.witClone; + return clone; + } +} + +/++ + ++/ +struct CChunkBatchEnd { + /++ + + +/ + int batchSize; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CChunkBatchEnd witClone() const @nogc nothrow { + CChunkBatchEnd clone = void; + clone.batchSize = this.batchSize.witClone; + return clone; + } +} + +/++ + ++/ +struct ChunkBiomeEntry { + /++ + + +/ + int chunkX; + + /++ + + +/ + int chunkZ; + + /++ + + +/ + WitList!(ubyte) data; + + void witFree() @nogc nothrow { + data.witFree; + } + + void witDrop() @nogc nothrow { + } + + ChunkBiomeEntry witClone() const @nogc nothrow { + ChunkBiomeEntry clone = void; + clone.chunkX = this.chunkX.witClone; + clone.chunkZ = this.chunkZ.witClone; + clone.data = this.data.witClone; + return clone; + } +} + +/++ + ++/ +struct CChunksBiomes { + /++ + + +/ + WitList!(ChunkBiomeEntry) chunks; + + void witFree() @nogc nothrow { + chunks.witFree; + } + + void witDrop() @nogc nothrow { + } + + CChunksBiomes witClone() const @nogc nothrow { + CChunksBiomes clone = void; + clone.chunks = this.chunks.witClone; + return clone; + } +} + +/++ + ++/ +struct CClearTitle { + /++ + + +/ + bool reset; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CClearTitle witClone() const @nogc nothrow { + CClearTitle clone = void; + clone.reset = this.reset.witClone; + return clone; + } +} + +/++ + ++/ +struct CCloseContainer { + /++ + + +/ + int syncId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CCloseContainer witClone() const @nogc nothrow { + CCloseContainer clone = void; + clone.syncId = this.syncId.witClone; + return clone; + } +} + +/++ + ++/ +struct CCombatDeath { + /++ + + +/ + int playerId; + + /++ + + +/ + WitString message; + + void witFree() @nogc nothrow { + message.witFree; + } + + void witDrop() @nogc nothrow { + } + + CCombatDeath witClone() const @nogc nothrow { + CCombatDeath clone = void; + clone.playerId = this.playerId.witClone; + clone.message = this.message.witClone; + return clone; + } +} + +/++ + ++/ +struct CCombatEnd { + /++ + + +/ + int durationTicks; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CCombatEnd witClone() const @nogc nothrow { + CCombatEnd clone = void; + clone.durationTicks = this.durationTicks.witClone; + return clone; + } +} + +/++ + ++/ +struct CommandSuggestion { + /++ + + +/ + WitString suggestion; + + /++ + + +/ + Option!(WitString) tooltip; + + void witFree() @nogc nothrow { + suggestion.witFree; + tooltip.witFree; + } + + void witDrop() @nogc nothrow { + } + + CommandSuggestion witClone() const @nogc nothrow { + CommandSuggestion clone = void; + clone.suggestion = this.suggestion.witClone; + clone.tooltip = this.tooltip.witClone; + return clone; + } +} + +/++ + ++/ +struct CCommandSuggestions { + /++ + + +/ + int id; + + /++ + + +/ + int start; + + /++ + + +/ + int length; + + /++ + + +/ + WitList!(CommandSuggestion) matches; + + void witFree() @nogc nothrow { + matches.witFree; + } + + void witDrop() @nogc nothrow { + } + + CCommandSuggestions witClone() const @nogc nothrow { + CCommandSuggestions clone = void; + clone.id = this.id.witClone; + clone.start = this.start.witClone; + clone.length = this.length.witClone; + clone.matches = this.matches.witClone; + return clone; + } +} + +/++ + ++/ +struct ProtoNodeTypeLiteral { + /++ + + +/ + WitString name; + + /++ + + +/ + bool isExecutable; + + /++ + + +/ + Option!(int) redirectTarget; + + /++ + + +/ + bool restricted; + + void witFree() @nogc nothrow { + name.witFree; + } + + void witDrop() @nogc nothrow { + } + + ProtoNodeTypeLiteral witClone() const @nogc nothrow { + ProtoNodeTypeLiteral clone = void; + clone.name = this.name.witClone; + clone.isExecutable = this.isExecutable.witClone; + clone.redirectTarget = this.redirectTarget.witClone; + clone.restricted = this.restricted.witClone; + return clone; + } +} + +/++ + ++/ +struct ArgumentTypeFloat { + /++ + + +/ + Option!(float) min; + + /++ + + +/ + Option!(float) max; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ArgumentTypeFloat witClone() const @nogc nothrow { + ArgumentTypeFloat clone = void; + clone.min = this.min.witClone; + clone.max = this.max.witClone; + return clone; + } +} + +/++ + ++/ +struct ArgumentTypeDouble { + /++ + + +/ + Option!(double) min; + + /++ + + +/ + Option!(double) max; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ArgumentTypeDouble witClone() const @nogc nothrow { + ArgumentTypeDouble clone = void; + clone.min = this.min.witClone; + clone.max = this.max.witClone; + return clone; + } +} + +/++ + ++/ +struct ArgumentTypeInteger { + /++ + + +/ + Option!(int) min; + + /++ + + +/ + Option!(int) max; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ArgumentTypeInteger witClone() const @nogc nothrow { + ArgumentTypeInteger clone = void; + clone.min = this.min.witClone; + clone.max = this.max.witClone; + return clone; + } +} + +/++ + ++/ +struct ArgumentTypeLong { + /++ + + +/ + Option!(long) min; + + /++ + + +/ + Option!(long) max; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ArgumentTypeLong witClone() const @nogc nothrow { + ArgumentTypeLong clone = void; + clone.min = this.min.witClone; + clone.max = this.max.witClone; + return clone; + } +} + +/++ + ++/ +struct ArgumentTypeEntity { + /++ + + +/ + ubyte flags; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ArgumentTypeEntity witClone() const @nogc nothrow { + ArgumentTypeEntity clone = void; + clone.flags = this.flags.witClone; + return clone; + } +} + +/++ + ++/ +struct ArgumentTypeScoreHolder { + /++ + + +/ + ubyte flags; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ArgumentTypeScoreHolder witClone() const @nogc nothrow { + ArgumentTypeScoreHolder clone = void; + clone.flags = this.flags.witClone; + return clone; + } +} + +/++ + ++/ +struct ArgumentTypeTime { + /++ + + +/ + int min; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ArgumentTypeTime witClone() const @nogc nothrow { + ArgumentTypeTime clone = void; + clone.min = this.min.witClone; + return clone; + } +} + +/++ + ++/ +struct ArgumentTypeResourceOrTag { + /++ + + +/ + WitString identifier; + + void witFree() @nogc nothrow { + identifier.witFree; + } + + void witDrop() @nogc nothrow { + } + + ArgumentTypeResourceOrTag witClone() const @nogc nothrow { + ArgumentTypeResourceOrTag clone = void; + clone.identifier = this.identifier.witClone; + return clone; + } +} + +/++ + ++/ +struct ArgumentTypeResourceOrTagKey { + /++ + + +/ + WitString identifier; + + void witFree() @nogc nothrow { + identifier.witFree; + } + + void witDrop() @nogc nothrow { + } + + ArgumentTypeResourceOrTagKey witClone() const @nogc nothrow { + ArgumentTypeResourceOrTagKey clone = void; + clone.identifier = this.identifier.witClone; + return clone; + } +} + +/++ + ++/ +struct ArgumentTypeResource { + /++ + + +/ + WitString identifier; + + void witFree() @nogc nothrow { + identifier.witFree; + } + + void witDrop() @nogc nothrow { + } + + ArgumentTypeResource witClone() const @nogc nothrow { + ArgumentTypeResource clone = void; + clone.identifier = this.identifier.witClone; + return clone; + } +} + +/++ + ++/ +struct ArgumentTypeResourceKey { + /++ + + +/ + WitString identifier; + + void witFree() @nogc nothrow { + identifier.witFree; + } + + void witDrop() @nogc nothrow { + } + + ArgumentTypeResourceKey witClone() const @nogc nothrow { + ArgumentTypeResourceKey clone = void; + clone.identifier = this.identifier.witClone; + return clone; + } +} + +/++ + ++/ +enum StringProtoArgBehavior : ubyte { + /++ + + +/ + singleWord, + + /++ + + +/ + quotablePhrase, + + /++ + + +/ + greedyPhrase, +} +/++ + ++/ +struct ArgumentType { + mixin WitVariant!( + void, // bool_ + ArgumentTypeFloat, // float_ + ArgumentTypeDouble, // double_ + ArgumentTypeInteger, // integer + ArgumentTypeLong, // long_ + StringProtoArgBehavior, // string + ArgumentTypeEntity, // entity + void, // gameProfile + void, // blockPos + void, // columnPos + void, // vec3 + void, // vec2 + void, // blockState + void, // blockPredicate + void, // itemStack + void, // itemPredicate + void, // color + void, // hexColor + void, // component + void, // style + void, // message + void, // nbtCompound + void, // nbtTag + void, // nbtPath + void, // objective + void, // objectiveCriteria + void, // operation + void, // particle + void, // angle + void, // rotation + void, // scoreboardSlot + ArgumentTypeScoreHolder, // scoreHolder + void, // swizzle + void, // team + void, // itemSlot + void, // itemSlots + void, // resourceLocation + void, // function_ + void, // entityAnchor + void, // intRange + void, // floatRange + void, // dimension + void, // gamemode + ArgumentTypeTime, // time + ArgumentTypeResourceOrTag, // resourceOrTag + ArgumentTypeResourceOrTagKey, // resourceOrTagKey + ArgumentTypeResource, // resource + ArgumentTypeResourceKey, // resourceKey + void, // resourceSelector + void, // templateMirror + void, // templateRotation + void, // heightmap + void, // lootTable + void, // lootPredicate + void, // lootModifier + void, // dialog + void, // uuid + ); + +public: + enum Tag : ubyte { + /++ + + +/ + bool_, + + /++ + + +/ + float_, + + /++ + + +/ + double_, + + /++ + + +/ + integer, + + /++ + + +/ + long_, + + /++ + + +/ + string, + + /++ + + +/ + entity, + + /++ + + +/ + gameProfile, + + /++ + + +/ + blockPos, + + /++ + + +/ + columnPos, + + /++ + + +/ + vec3, + + /++ + + +/ + vec2, + + /++ + + +/ + blockState, + + /++ + + +/ + blockPredicate, + + /++ + + +/ + itemStack, + + /++ + + +/ + itemPredicate, + + /++ + + +/ + color, + + /++ + + +/ + hexColor, + + /++ + + +/ + component, + + /++ + + +/ + style, + + /++ + + +/ + message, + + /++ + + +/ + nbtCompound, + + /++ + + +/ + nbtTag, + + /++ + + +/ + nbtPath, + + /++ + + +/ + objective, + + /++ + + +/ + objectiveCriteria, + + /++ + + +/ + operation, + + /++ + + +/ + particle, + + /++ + + +/ + angle, + + /++ + + +/ + rotation, + + /++ + + +/ + scoreboardSlot, + + /++ + + +/ + scoreHolder, + + /++ + + +/ + swizzle, + + /++ + + +/ + team, + + /++ + + +/ + itemSlot, + + /++ + + +/ + itemSlots, + + /++ + + +/ + resourceLocation, + + /++ + + +/ + function_, + + /++ + + +/ + entityAnchor, + + /++ + + +/ + intRange, + + /++ + + +/ + floatRange, + + /++ + + +/ + dimension, + + /++ + + +/ + gamemode, + + /++ + + +/ + time, + + /++ + + +/ + resourceOrTag, + + /++ + + +/ + resourceOrTagKey, + + /++ + + +/ + resource, + + /++ + + +/ + resourceKey, + + /++ + + +/ + resourceSelector, + + /++ + + +/ + templateMirror, + + /++ + + +/ + templateRotation, + + /++ + + +/ + heightmap, + + /++ + + +/ + lootTable, + + /++ + + +/ + lootPredicate, + + /++ + + +/ + lootModifier, + + /++ + + +/ + dialog, + + /++ + + +/ + uuid, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias bool_ = _create!(Tag.bool_); + /// ditto + pragma(inline, true) bool isBool() const => _tag == Tag.bool_; + + /++ + + +/ + alias float_ = _create!(Tag.float_); + /// ditto + pragma(inline, true) bool isFloat() const => _tag == Tag.float_; + ///ditto + alias getFloat = _get!(Tag.float_); + + /++ + + +/ + alias double_ = _create!(Tag.double_); + /// ditto + pragma(inline, true) bool isDouble() const => _tag == Tag.double_; + ///ditto + alias getDouble = _get!(Tag.double_); + + /++ + + +/ + alias integer = _create!(Tag.integer); + /// ditto + pragma(inline, true) bool isInteger() const => _tag == Tag.integer; + ///ditto + alias getInteger = _get!(Tag.integer); + + /++ + + +/ + alias long_ = _create!(Tag.long_); + /// ditto + pragma(inline, true) bool isLong() const => _tag == Tag.long_; + ///ditto + alias getLong = _get!(Tag.long_); + + /++ + + +/ + alias string = _create!(Tag.string); + /// ditto + pragma(inline, true) bool isString() const => _tag == Tag.string; + ///ditto + alias getString = _get!(Tag.string); + + /++ + + +/ + alias entity = _create!(Tag.entity); + /// ditto + pragma(inline, true) bool isEntity() const => _tag == Tag.entity; + ///ditto + alias getEntity = _get!(Tag.entity); + + /++ + + +/ + alias gameProfile = _create!(Tag.gameProfile); + /// ditto + pragma(inline, true) bool isGameProfile() const => _tag == Tag.gameProfile; + + /++ + + +/ + alias blockPos = _create!(Tag.blockPos); + /// ditto + pragma(inline, true) bool isBlockPos() const => _tag == Tag.blockPos; + + /++ + + +/ + alias columnPos = _create!(Tag.columnPos); + /// ditto + pragma(inline, true) bool isColumnPos() const => _tag == Tag.columnPos; + + /++ + + +/ + alias vec3 = _create!(Tag.vec3); + /// ditto + pragma(inline, true) bool isVec3() const => _tag == Tag.vec3; + + /++ + + +/ + alias vec2 = _create!(Tag.vec2); + /// ditto + pragma(inline, true) bool isVec2() const => _tag == Tag.vec2; + + /++ + + +/ + alias blockState = _create!(Tag.blockState); + /// ditto + pragma(inline, true) bool isBlockState() const => _tag == Tag.blockState; + + /++ + + +/ + alias blockPredicate = _create!(Tag.blockPredicate); + /// ditto + pragma(inline, true) bool isBlockPredicate() const => _tag == Tag.blockPredicate; + + /++ + + +/ + alias itemStack = _create!(Tag.itemStack); + /// ditto + pragma(inline, true) bool isItemStack() const => _tag == Tag.itemStack; + + /++ + + +/ + alias itemPredicate = _create!(Tag.itemPredicate); + /// ditto + pragma(inline, true) bool isItemPredicate() const => _tag == Tag.itemPredicate; + + /++ + + +/ + alias color = _create!(Tag.color); + /// ditto + pragma(inline, true) bool isColor() const => _tag == Tag.color; + + /++ + + +/ + alias hexColor = _create!(Tag.hexColor); + /// ditto + pragma(inline, true) bool isHexColor() const => _tag == Tag.hexColor; + + /++ + + +/ + alias component = _create!(Tag.component); + /// ditto + pragma(inline, true) bool isComponent() const => _tag == Tag.component; + + /++ + + +/ + alias style = _create!(Tag.style); + /// ditto + pragma(inline, true) bool isStyle() const => _tag == Tag.style; + + /++ + + +/ + alias message = _create!(Tag.message); + /// ditto + pragma(inline, true) bool isMessage() const => _tag == Tag.message; + + /++ + + +/ + alias nbtCompound = _create!(Tag.nbtCompound); + /// ditto + pragma(inline, true) bool isNbtCompound() const => _tag == Tag.nbtCompound; + + /++ + + +/ + alias nbtTag = _create!(Tag.nbtTag); + /// ditto + pragma(inline, true) bool isNbtTag() const => _tag == Tag.nbtTag; + + /++ + + +/ + alias nbtPath = _create!(Tag.nbtPath); + /// ditto + pragma(inline, true) bool isNbtPath() const => _tag == Tag.nbtPath; + + /++ + + +/ + alias objective = _create!(Tag.objective); + /// ditto + pragma(inline, true) bool isObjective() const => _tag == Tag.objective; + + /++ + + +/ + alias objectiveCriteria = _create!(Tag.objectiveCriteria); + /// ditto + pragma(inline, true) bool isObjectiveCriteria() const => _tag == Tag.objectiveCriteria; + + /++ + + +/ + alias operation = _create!(Tag.operation); + /// ditto + pragma(inline, true) bool isOperation() const => _tag == Tag.operation; + + /++ + + +/ + alias particle = _create!(Tag.particle); + /// ditto + pragma(inline, true) bool isParticle() const => _tag == Tag.particle; + + /++ + + +/ + alias angle = _create!(Tag.angle); + /// ditto + pragma(inline, true) bool isAngle() const => _tag == Tag.angle; + + /++ + + +/ + alias rotation = _create!(Tag.rotation); + /// ditto + pragma(inline, true) bool isRotation() const => _tag == Tag.rotation; + + /++ + + +/ + alias scoreboardSlot = _create!(Tag.scoreboardSlot); + /// ditto + pragma(inline, true) bool isScoreboardSlot() const => _tag == Tag.scoreboardSlot; + + /++ + + +/ + alias scoreHolder = _create!(Tag.scoreHolder); + /// ditto + pragma(inline, true) bool isScoreHolder() const => _tag == Tag.scoreHolder; + ///ditto + alias getScoreHolder = _get!(Tag.scoreHolder); + + /++ + + +/ + alias swizzle = _create!(Tag.swizzle); + /// ditto + pragma(inline, true) bool isSwizzle() const => _tag == Tag.swizzle; + + /++ + + +/ + alias team = _create!(Tag.team); + /// ditto + pragma(inline, true) bool isTeam() const => _tag == Tag.team; + + /++ + + +/ + alias itemSlot = _create!(Tag.itemSlot); + /// ditto + pragma(inline, true) bool isItemSlot() const => _tag == Tag.itemSlot; + + /++ + + +/ + alias itemSlots = _create!(Tag.itemSlots); + /// ditto + pragma(inline, true) bool isItemSlots() const => _tag == Tag.itemSlots; + + /++ + + +/ + alias resourceLocation = _create!(Tag.resourceLocation); + /// ditto + pragma(inline, true) bool isResourceLocation() const => _tag == Tag.resourceLocation; + + /++ + + +/ + alias function_ = _create!(Tag.function_); + /// ditto + pragma(inline, true) bool isFunction() const => _tag == Tag.function_; + + /++ + + +/ + alias entityAnchor = _create!(Tag.entityAnchor); + /// ditto + pragma(inline, true) bool isEntityAnchor() const => _tag == Tag.entityAnchor; + + /++ + + +/ + alias intRange = _create!(Tag.intRange); + /// ditto + pragma(inline, true) bool isIntRange() const => _tag == Tag.intRange; + + /++ + + +/ + alias floatRange = _create!(Tag.floatRange); + /// ditto + pragma(inline, true) bool isFloatRange() const => _tag == Tag.floatRange; + + /++ + + +/ + alias dimension = _create!(Tag.dimension); + /// ditto + pragma(inline, true) bool isDimension() const => _tag == Tag.dimension; + + /++ + + +/ + alias gamemode = _create!(Tag.gamemode); + /// ditto + pragma(inline, true) bool isGamemode() const => _tag == Tag.gamemode; + + /++ + + +/ + alias time = _create!(Tag.time); + /// ditto + pragma(inline, true) bool isTime() const => _tag == Tag.time; + ///ditto + alias getTime = _get!(Tag.time); + + /++ + + +/ + alias resourceOrTag = _create!(Tag.resourceOrTag); + /// ditto + pragma(inline, true) bool isResourceOrTag() const => _tag == Tag.resourceOrTag; + ///ditto + alias getResourceOrTag = _get!(Tag.resourceOrTag); + + /++ + + +/ + alias resourceOrTagKey = _create!(Tag.resourceOrTagKey); + /// ditto + pragma(inline, true) bool isResourceOrTagKey() const => _tag == Tag.resourceOrTagKey; + ///ditto + alias getResourceOrTagKey = _get!(Tag.resourceOrTagKey); + + /++ + + +/ + alias resource = _create!(Tag.resource); + /// ditto + pragma(inline, true) bool isResource() const => _tag == Tag.resource; + ///ditto + alias getResource = _get!(Tag.resource); + + /++ + + +/ + alias resourceKey = _create!(Tag.resourceKey); + /// ditto + pragma(inline, true) bool isResourceKey() const => _tag == Tag.resourceKey; + ///ditto + alias getResourceKey = _get!(Tag.resourceKey); + + /++ + + +/ + alias resourceSelector = _create!(Tag.resourceSelector); + /// ditto + pragma(inline, true) bool isResourceSelector() const => _tag == Tag.resourceSelector; + + /++ + + +/ + alias templateMirror = _create!(Tag.templateMirror); + /// ditto + pragma(inline, true) bool isTemplateMirror() const => _tag == Tag.templateMirror; + + /++ + + +/ + alias templateRotation = _create!(Tag.templateRotation); + /// ditto + pragma(inline, true) bool isTemplateRotation() const => _tag == Tag.templateRotation; + + /++ + + +/ + alias heightmap = _create!(Tag.heightmap); + /// ditto + pragma(inline, true) bool isHeightmap() const => _tag == Tag.heightmap; + + /++ + + +/ + alias lootTable = _create!(Tag.lootTable); + /// ditto + pragma(inline, true) bool isLootTable() const => _tag == Tag.lootTable; + + /++ + + +/ + alias lootPredicate = _create!(Tag.lootPredicate); + /// ditto + pragma(inline, true) bool isLootPredicate() const => _tag == Tag.lootPredicate; + + /++ + + +/ + alias lootModifier = _create!(Tag.lootModifier); + /// ditto + pragma(inline, true) bool isLootModifier() const => _tag == Tag.lootModifier; + + /++ + + +/ + alias dialog = _create!(Tag.dialog); + /// ditto + pragma(inline, true) bool isDialog() const => _tag == Tag.dialog; + + /++ + + +/ + alias uuid = _create!(Tag.uuid); + /// ditto + pragma(inline, true) bool isUuid() const => _tag == Tag.uuid; + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case resourceOrTag: _get!(Tag.resourceOrTag).witFree; break; + case resourceOrTagKey: _get!(Tag.resourceOrTagKey).witFree; break; + case resource: _get!(Tag.resource).witFree; break; + case resourceKey: _get!(Tag.resourceKey).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + } + + ArgumentType witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.bool_: return _create!(Tag.bool_); break; + case Tag.float_: return _create!(Tag.float_)(this._get!(Tag.float_).witClone); break; + case Tag.double_: return _create!(Tag.double_)(this._get!(Tag.double_).witClone); break; + case Tag.integer: return _create!(Tag.integer)(this._get!(Tag.integer).witClone); break; + case Tag.long_: return _create!(Tag.long_)(this._get!(Tag.long_).witClone); break; + case Tag.string: return _create!(Tag.string)(this._get!(Tag.string).witClone); break; + case Tag.entity: return _create!(Tag.entity)(this._get!(Tag.entity).witClone); break; + case Tag.gameProfile: return _create!(Tag.gameProfile); break; + case Tag.blockPos: return _create!(Tag.blockPos); break; + case Tag.columnPos: return _create!(Tag.columnPos); break; + case Tag.vec3: return _create!(Tag.vec3); break; + case Tag.vec2: return _create!(Tag.vec2); break; + case Tag.blockState: return _create!(Tag.blockState); break; + case Tag.blockPredicate: return _create!(Tag.blockPredicate); break; + case Tag.itemStack: return _create!(Tag.itemStack); break; + case Tag.itemPredicate: return _create!(Tag.itemPredicate); break; + case Tag.color: return _create!(Tag.color); break; + case Tag.hexColor: return _create!(Tag.hexColor); break; + case Tag.component: return _create!(Tag.component); break; + case Tag.style: return _create!(Tag.style); break; + case Tag.message: return _create!(Tag.message); break; + case Tag.nbtCompound: return _create!(Tag.nbtCompound); break; + case Tag.nbtTag: return _create!(Tag.nbtTag); break; + case Tag.nbtPath: return _create!(Tag.nbtPath); break; + case Tag.objective: return _create!(Tag.objective); break; + case Tag.objectiveCriteria: return _create!(Tag.objectiveCriteria); break; + case Tag.operation: return _create!(Tag.operation); break; + case Tag.particle: return _create!(Tag.particle); break; + case Tag.angle: return _create!(Tag.angle); break; + case Tag.rotation: return _create!(Tag.rotation); break; + case Tag.scoreboardSlot: return _create!(Tag.scoreboardSlot); break; + case Tag.scoreHolder: return _create!(Tag.scoreHolder)(this._get!(Tag.scoreHolder).witClone); break; + case Tag.swizzle: return _create!(Tag.swizzle); break; + case Tag.team: return _create!(Tag.team); break; + case Tag.itemSlot: return _create!(Tag.itemSlot); break; + case Tag.itemSlots: return _create!(Tag.itemSlots); break; + case Tag.resourceLocation: return _create!(Tag.resourceLocation); break; + case Tag.function_: return _create!(Tag.function_); break; + case Tag.entityAnchor: return _create!(Tag.entityAnchor); break; + case Tag.intRange: return _create!(Tag.intRange); break; + case Tag.floatRange: return _create!(Tag.floatRange); break; + case Tag.dimension: return _create!(Tag.dimension); break; + case Tag.gamemode: return _create!(Tag.gamemode); break; + case Tag.time: return _create!(Tag.time)(this._get!(Tag.time).witClone); break; + case Tag.resourceOrTag: return _create!(Tag.resourceOrTag)(this._get!(Tag.resourceOrTag).witClone); break; + case Tag.resourceOrTagKey: return _create!(Tag.resourceOrTagKey)(this._get!(Tag.resourceOrTagKey).witClone); break; + case Tag.resource: return _create!(Tag.resource)(this._get!(Tag.resource).witClone); break; + case Tag.resourceKey: return _create!(Tag.resourceKey)(this._get!(Tag.resourceKey).witClone); break; + case Tag.resourceSelector: return _create!(Tag.resourceSelector); break; + case Tag.templateMirror: return _create!(Tag.templateMirror); break; + case Tag.templateRotation: return _create!(Tag.templateRotation); break; + case Tag.heightmap: return _create!(Tag.heightmap); break; + case Tag.lootTable: return _create!(Tag.lootTable); break; + case Tag.lootPredicate: return _create!(Tag.lootPredicate); break; + case Tag.lootModifier: return _create!(Tag.lootModifier); break; + case Tag.dialog: return _create!(Tag.dialog); break; + case Tag.uuid: return _create!(Tag.uuid); break; + } + } +} + +/++ + ++/ +enum SuggestionProviders : ubyte { + /++ + + +/ + askServer, + + /++ + + +/ + allRecipes, + + /++ + + +/ + availableSounds, + + /++ + + +/ + summonableEntities, +} +/++ + ++/ +struct ProtoNodeTypeArgument { + /++ + + +/ + WitString name; + + /++ + + +/ + bool isExecutable; + + /++ + + +/ + Option!(int) redirectTarget; + + /++ + + +/ + ArgumentType parser; + + /++ + + +/ + Option!(SuggestionProviders) overrideSuggestionType; + + /++ + + +/ + bool restricted; + + void witFree() @nogc nothrow { + name.witFree; + parser.witFree; + } + + void witDrop() @nogc nothrow { + } + + ProtoNodeTypeArgument witClone() const @nogc nothrow { + ProtoNodeTypeArgument clone = void; + clone.name = this.name.witClone; + clone.isExecutable = this.isExecutable.witClone; + clone.redirectTarget = this.redirectTarget.witClone; + clone.parser = this.parser.witClone; + clone.overrideSuggestionType = this.overrideSuggestionType.witClone; + clone.restricted = this.restricted.witClone; + return clone; + } +} + +/++ + ++/ +struct ProtoNodeType { + mixin WitVariant!( + void, // root + ProtoNodeTypeLiteral, // literal + ProtoNodeTypeArgument, // argument + ); + +public: + enum Tag : ubyte { + /++ + + +/ + root, + + /++ + + +/ + literal, + + /++ + + +/ + argument, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias root = _create!(Tag.root); + /// ditto + pragma(inline, true) bool isRoot() const => _tag == Tag.root; + + /++ + + +/ + alias literal = _create!(Tag.literal); + /// ditto + pragma(inline, true) bool isLiteral() const => _tag == Tag.literal; + ///ditto + alias getLiteral = _get!(Tag.literal); + + /++ + + +/ + alias argument = _create!(Tag.argument); + /// ditto + pragma(inline, true) bool isArgument() const => _tag == Tag.argument; + ///ditto + alias getArgument = _get!(Tag.argument); + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case literal: _get!(Tag.literal).witFree; break; + case argument: _get!(Tag.argument).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + } + + ProtoNodeType witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.root: return _create!(Tag.root); break; + case Tag.literal: return _create!(Tag.literal)(this._get!(Tag.literal).witClone); break; + case Tag.argument: return _create!(Tag.argument)(this._get!(Tag.argument).witClone); break; + } + } +} + +/++ + ++/ +struct ProtoNode { + /++ + + +/ + WitList!(int) children; + + /++ + + +/ + ProtoNodeType nodeType; + + void witFree() @nogc nothrow { + children.witFree; + nodeType.witFree; + } + + void witDrop() @nogc nothrow { + } + + ProtoNode witClone() const @nogc nothrow { + ProtoNode clone = void; + clone.children = this.children.witClone; + clone.nodeType = this.nodeType.witClone; + return clone; + } +} + +/++ + ++/ +struct CCommands { + /++ + + +/ + WitList!(ProtoNode) nodes; + + /++ + + +/ + int rootNodeIndex; + + void witFree() @nogc nothrow { + nodes.witFree; + } + + void witDrop() @nogc nothrow { + } + + CCommands witClone() const @nogc nothrow { + CCommands clone = void; + clone.nodes = this.nodes.witClone; + clone.rootNodeIndex = this.rootNodeIndex.witClone; + return clone; + } +} + +/++ + ++/ +struct CPlayCookieRequest { + /++ + + +/ + WitString key; + + void witFree() @nogc nothrow { + key.witFree; + } + + void witDrop() @nogc nothrow { + } + + CPlayCookieRequest witClone() const @nogc nothrow { + CPlayCookieRequest clone = void; + clone.key = this.key.witClone; + return clone; + } +} + +/++ + ++/ +struct CCustomChatCompletions { + /++ + + +/ + int action; + + /++ + + +/ + WitList!(WitString) entries; + + void witFree() @nogc nothrow { + entries.witFree; + } + + void witDrop() @nogc nothrow { + } + + CCustomChatCompletions witClone() const @nogc nothrow { + CCustomChatCompletions clone = void; + clone.action = this.action.witClone; + clone.entries = this.entries.witClone; + return clone; + } +} + +/++ + ++/ +struct CCustomPayload { + /++ + + +/ + WitString channel; + + /++ + + +/ + WitList!(ubyte) data; + + void witFree() @nogc nothrow { + channel.witFree; + data.witFree; + } + + void witDrop() @nogc nothrow { + } + + CCustomPayload witClone() const @nogc nothrow { + CCustomPayload clone = void; + clone.channel = this.channel.witClone; + clone.data = this.data.witClone; + return clone; + } +} + +/++ + ++/ +struct CPlayCustomReportDetails { + /++ + + +/ + WitList!(Tuple!(WitString, WitString)) details; + + void witFree() @nogc nothrow { + details.witFree; + } + + void witDrop() @nogc nothrow { + } + + CPlayCustomReportDetails witClone() const @nogc nothrow { + CPlayCustomReportDetails clone = void; + clone.details = this.details.witClone; + return clone; + } +} + +/++ + ++/ +struct CDamageEvent { + /++ + + +/ + int entityId; + + /++ + + +/ + int sourceTypeId; + + /++ + + +/ + int sourceCauseId; + + /++ + + +/ + int sourceDirectId; + + /++ + + +/ + Option!(Tuple!(double, double, double)) sourcePosition; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CDamageEvent witClone() const @nogc nothrow { + CDamageEvent clone = void; + clone.entityId = this.entityId.witClone; + clone.sourceTypeId = this.sourceTypeId.witClone; + clone.sourceCauseId = this.sourceCauseId.witClone; + clone.sourceDirectId = this.sourceDirectId.witClone; + clone.sourcePosition = this.sourcePosition.witClone; + return clone; + } +} + +/++ + ++/ +struct CDebugBlockValue { + /++ + + +/ + Tuple!(int, int, int) pos; + + /++ + + +/ + WitString name; + + /++ + + +/ + WitString value; + + void witFree() @nogc nothrow { + name.witFree; + value.witFree; + } + + void witDrop() @nogc nothrow { + } + + CDebugBlockValue witClone() const @nogc nothrow { + CDebugBlockValue clone = void; + clone.pos = this.pos.witClone; + clone.name = this.name.witClone; + clone.value = this.value.witClone; + return clone; + } +} + +/++ + ++/ +struct CDebugChunkValue { + /++ + + +/ + Tuple!(double, double) chunkPos; + + /++ + + +/ + WitString name; + + /++ + + +/ + WitString value; + + void witFree() @nogc nothrow { + name.witFree; + value.witFree; + } + + void witDrop() @nogc nothrow { + } + + CDebugChunkValue witClone() const @nogc nothrow { + CDebugChunkValue clone = void; + clone.chunkPos = this.chunkPos.witClone; + clone.name = this.name.witClone; + clone.value = this.value.witClone; + return clone; + } +} + +/++ + ++/ +struct CDebugEntityValue { + /++ + + +/ + int entityId; + + /++ + + +/ + WitString name; + + /++ + + +/ + WitString value; + + void witFree() @nogc nothrow { + name.witFree; + value.witFree; + } + + void witDrop() @nogc nothrow { + } + + CDebugEntityValue witClone() const @nogc nothrow { + CDebugEntityValue clone = void; + clone.entityId = this.entityId.witClone; + clone.name = this.name.witClone; + clone.value = this.value.witClone; + return clone; + } +} + +/++ + ++/ +struct CDebugEvent { + /++ + + +/ + WitString name; + + /++ + + +/ + WitList!(ubyte) data; + + void witFree() @nogc nothrow { + name.witFree; + data.witFree; + } + + void witDrop() @nogc nothrow { + } + + CDebugEvent witClone() const @nogc nothrow { + CDebugEvent clone = void; + clone.name = this.name.witClone; + clone.data = this.data.witClone; + return clone; + } +} + +/++ + ++/ +struct CDebugSample { + /++ + + +/ + WitList!(long) sample; + + /++ + + +/ + int sampleType; + + void witFree() @nogc nothrow { + sample.witFree; + } + + void witDrop() @nogc nothrow { + } + + CDebugSample witClone() const @nogc nothrow { + CDebugSample clone = void; + clone.sample = this.sample.witClone; + clone.sampleType = this.sampleType.witClone; + return clone; + } +} + +/++ + ++/ +struct CDeleteChat { + /++ + + +/ + int signatureId; + + /++ + + +/ + Option!(WitList!(ubyte)) signature; + + void witFree() @nogc nothrow { + signature.witFree; + } + + void witDrop() @nogc nothrow { + } + + CDeleteChat witClone() const @nogc nothrow { + CDeleteChat clone = void; + clone.signatureId = this.signatureId.witClone; + clone.signature = this.signature.witClone; + return clone; + } +} + +/++ + ++/ +struct CPlayDisconnect { + /++ + + +/ + WitString reason; + + void witFree() @nogc nothrow { + reason.witFree; + } + + void witDrop() @nogc nothrow { + } + + CPlayDisconnect witClone() const @nogc nothrow { + CPlayDisconnect clone = void; + clone.reason = this.reason.witClone; + return clone; + } +} + +/++ + ++/ +struct CDisguisedChatMessage { + /++ + + +/ + WitString message; + + /++ + + +/ + int chatType; + + /++ + + +/ + WitString senderName; + + /++ + + +/ + Option!(WitString) targetName; + + void witFree() @nogc nothrow { + message.witFree; + senderName.witFree; + targetName.witFree; + } + + void witDrop() @nogc nothrow { + } + + CDisguisedChatMessage witClone() const @nogc nothrow { + CDisguisedChatMessage clone = void; + clone.message = this.message.witClone; + clone.chatType = this.chatType.witClone; + clone.senderName = this.senderName.witClone; + clone.targetName = this.targetName.witClone; + return clone; + } +} + +/++ + ++/ +struct CDisplayObjective { + /++ + + +/ + int position; + + /++ + + +/ + WitString scoreName; + + void witFree() @nogc nothrow { + scoreName.witFree; + } + + void witDrop() @nogc nothrow { + } + + CDisplayObjective witClone() const @nogc nothrow { + CDisplayObjective clone = void; + clone.position = this.position.witClone; + clone.scoreName = this.scoreName.witClone; + return clone; + } +} + +/++ + ++/ +struct CEntityAnimation { + /++ + + +/ + int entityId; + + /++ + + +/ + ubyte animation; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CEntityAnimation witClone() const @nogc nothrow { + CEntityAnimation clone = void; + clone.entityId = this.entityId.witClone; + clone.animation = this.animation.witClone; + return clone; + } +} + +/++ + ++/ +enum Animation : ubyte { + /++ + + +/ + swingMainArm, + + /++ + + +/ + leaveBed, + + /++ + + +/ + swingOffhand, + + /++ + + +/ + criticalEffect, + + /++ + + +/ + magicCriticaleffect, +} +/++ + ++/ +struct CSetEntityMetadata { + /++ + + +/ + int entityId; + + /++ + + +/ + WitList!(ubyte) metadata; + + void witFree() @nogc nothrow { + metadata.witFree; + } + + void witDrop() @nogc nothrow { + } + + CSetEntityMetadata witClone() const @nogc nothrow { + CSetEntityMetadata clone = void; + clone.entityId = this.entityId.witClone; + clone.metadata = this.metadata.witClone; + return clone; + } +} + +/++ + ++/ +struct CEntityPositionSync { + /++ + + +/ + int entityId; + + /++ + + +/ + Tuple!(double, double, double) position; + + /++ + + +/ + Tuple!(double, double, double) delta; + + /++ + + +/ + float yaw; + + /++ + + +/ + float pitch; + + /++ + + +/ + bool onGround; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CEntityPositionSync witClone() const @nogc nothrow { + CEntityPositionSync clone = void; + clone.entityId = this.entityId.witClone; + clone.position = this.position.witClone; + clone.delta = this.delta.witClone; + clone.yaw = this.yaw.witClone; + clone.pitch = this.pitch.witClone; + clone.onGround = this.onGround.witClone; + return clone; + } +} + +/++ + ++/ +struct CEntitySoundEffect { + /++ + + +/ + WitString soundEvent; + + /++ + + +/ + int soundCategory; + + /++ + + +/ + int entityId; + + /++ + + +/ + float volume; + + /++ + + +/ + float pitch; + + /++ + + +/ + long seed; + + void witFree() @nogc nothrow { + soundEvent.witFree; + } + + void witDrop() @nogc nothrow { + } + + CEntitySoundEffect witClone() const @nogc nothrow { + CEntitySoundEffect clone = void; + clone.soundEvent = this.soundEvent.witClone; + clone.soundCategory = this.soundCategory.witClone; + clone.entityId = this.entityId.witClone; + clone.volume = this.volume.witClone; + clone.pitch = this.pitch.witClone; + clone.seed = this.seed.witClone; + return clone; + } +} + +/++ + ++/ +struct CEntityStatus { + /++ + + +/ + int entityId; + + /++ + + +/ + ubyte entityStatus; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CEntityStatus witClone() const @nogc nothrow { + CEntityStatus clone = void; + clone.entityId = this.entityId.witClone; + clone.entityStatus = this.entityStatus.witClone; + return clone; + } +} + +/++ + ++/ +struct CEntityVelocity { + /++ + + +/ + int entityId; + + /++ + + +/ + WitString velocity; + + void witFree() @nogc nothrow { + velocity.witFree; + } + + void witDrop() @nogc nothrow { + } + + CEntityVelocity witClone() const @nogc nothrow { + CEntityVelocity clone = void; + clone.entityId = this.entityId.witClone; + clone.velocity = this.velocity.witClone; + return clone; + } +} + +/++ + ++/ +struct CExplosion { + /++ + + +/ + Tuple!(double, double, double) center; + + /++ + + +/ + float radius; + + /++ + + +/ + int blockCount; + + /++ + + +/ + Option!(Tuple!(double, double, double)) knockback; + + /++ + + +/ + int particle; + + /++ + + +/ + WitString sound; + + /++ + + +/ + int blockParticlesPoolSize; + + void witFree() @nogc nothrow { + sound.witFree; + } + + void witDrop() @nogc nothrow { + } + + CExplosion witClone() const @nogc nothrow { + CExplosion clone = void; + clone.center = this.center.witClone; + clone.radius = this.radius.witClone; + clone.blockCount = this.blockCount.witClone; + clone.knockback = this.knockback.witClone; + clone.particle = this.particle.witClone; + clone.sound = this.sound.witClone; + clone.blockParticlesPoolSize = this.blockParticlesPoolSize.witClone; + return clone; + } +} + +/++ + ++/ +struct CGameEvent { + /++ + + +/ + ubyte event; + + /++ + + +/ + float value; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CGameEvent witClone() const @nogc nothrow { + CGameEvent clone = void; + clone.event = this.event.witClone; + clone.value = this.value.witClone; + return clone; + } +} + +/++ + ++/ +enum GameEvent : ubyte { + /++ + + +/ + noRespawnBlockAvailable, + + /++ + + +/ + beginRaining, + + /++ + + +/ + endRaining, + + /++ + + +/ + changeGameMode, + + /++ + + +/ + winGame, + + /++ + + +/ + demoEvent, + + /++ + + +/ + arrowHitPlayer, + + /++ + + +/ + rainLevelChange, + + /++ + + +/ + thunderLevelChange, + + /++ + + +/ + playPufferfishStringSound, + + /++ + + +/ + playElderGuardianMobAppearance, + + /++ + + +/ + enabledRespawnScreen, + + /++ + + +/ + limitedCrafting, + + /++ + + +/ + startWaitingChunks, +} +/++ + ++/ +struct CGameRuleValues { + /++ + + +/ + WitList!(Tuple!(WitString, WitString)) rules; + + void witFree() @nogc nothrow { + rules.witFree; + } + + void witDrop() @nogc nothrow { + } + + CGameRuleValues witClone() const @nogc nothrow { + CGameRuleValues clone = void; + clone.rules = this.rules.witClone; + return clone; + } +} + +/++ + ++/ +struct CGameTestHighlightPos { + /++ + + +/ + Tuple!(int, int, int) pos; + + /++ + + +/ + int color; + + /++ + + +/ + WitString label; + + /++ + + +/ + int durationMs; + + void witFree() @nogc nothrow { + label.witFree; + } + + void witDrop() @nogc nothrow { + } + + CGameTestHighlightPos witClone() const @nogc nothrow { + CGameTestHighlightPos clone = void; + clone.pos = this.pos.witClone; + clone.color = this.color.witClone; + clone.label = this.label.witClone; + clone.durationMs = this.durationMs.witClone; + return clone; + } +} + +/++ + ++/ +struct CHeadRot { + /++ + + +/ + int entityId; + + /++ + + +/ + ubyte headYaw; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CHeadRot witClone() const @nogc nothrow { + CHeadRot clone = void; + clone.entityId = this.entityId.witClone; + clone.headYaw = this.headYaw.witClone; + return clone; + } +} + +/++ + ++/ +struct CHurtAnimation { + /++ + + +/ + int entityId; + + /++ + + +/ + float yaw; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CHurtAnimation witClone() const @nogc nothrow { + CHurtAnimation clone = void; + clone.entityId = this.entityId.witClone; + clone.yaw = this.yaw.witClone; + return clone; + } +} + +/++ + ++/ +struct CInitializeWorldBorder { + /++ + + +/ + double x; + + /++ + + +/ + double z; + + /++ + + +/ + double oldDiameter; + + /++ + + +/ + double newDiameter; + + /++ + + +/ + long speed; + + /++ + + +/ + int portalTeleportBoundary; + + /++ + + +/ + int warningBlocks; + + /++ + + +/ + int warningTime; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CInitializeWorldBorder witClone() const @nogc nothrow { + CInitializeWorldBorder clone = void; + clone.x = this.x.witClone; + clone.z = this.z.witClone; + clone.oldDiameter = this.oldDiameter.witClone; + clone.newDiameter = this.newDiameter.witClone; + clone.speed = this.speed.witClone; + clone.portalTeleportBoundary = this.portalTeleportBoundary.witClone; + clone.warningBlocks = this.warningBlocks.witClone; + clone.warningTime = this.warningTime.witClone; + return clone; + } +} + +/++ + ++/ +struct CItemCooldown { + /++ + + +/ + WitString group; + + /++ + + +/ + int cooldown; + + void witFree() @nogc nothrow { + group.witFree; + } + + void witDrop() @nogc nothrow { + } + + CItemCooldown witClone() const @nogc nothrow { + CItemCooldown clone = void; + clone.group = this.group.witClone; + clone.cooldown = this.cooldown.witClone; + return clone; + } +} + +/++ + ++/ +struct CKeepAlive { + /++ + + +/ + long keepAliveId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CKeepAlive witClone() const @nogc nothrow { + CKeepAlive clone = void; + clone.keepAliveId = this.keepAliveId.witClone; + return clone; + } +} + +/++ + ++/ +struct CLevelEvent { + /++ + + +/ + int event; + + /++ + + +/ + Tuple!(int, int, int) location; + + /++ + + +/ + int data; + + /++ + + +/ + bool disableRelativeVolume; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CLevelEvent witClone() const @nogc nothrow { + CLevelEvent clone = void; + clone.event = this.event.witClone; + clone.location = this.location.witClone; + clone.data = this.data.witClone; + clone.disableRelativeVolume = this.disableRelativeVolume.witClone; + return clone; + } +} + +/++ + ++/ +struct LightData { + /++ + + +/ + bool trustEdges; + + /++ + + +/ + WitList!(long) skyLightMask; + + /++ + + +/ + WitList!(long) blockLightMask; + + /++ + + +/ + WitList!(long) emptySkyLightMask; + + /++ + + +/ + WitList!(long) emptyBlockLightMask; + + /++ + + +/ + WitList!(WitList!(ubyte)) skyLightArrays; + + /++ + + +/ + WitList!(WitList!(ubyte)) blockLightArrays; + + void witFree() @nogc nothrow { + skyLightMask.witFree; + blockLightMask.witFree; + emptySkyLightMask.witFree; + emptyBlockLightMask.witFree; + skyLightArrays.witFree; + blockLightArrays.witFree; + } + + void witDrop() @nogc nothrow { + } + + LightData witClone() const @nogc nothrow { + LightData clone = void; + clone.trustEdges = this.trustEdges.witClone; + clone.skyLightMask = this.skyLightMask.witClone; + clone.blockLightMask = this.blockLightMask.witClone; + clone.emptySkyLightMask = this.emptySkyLightMask.witClone; + clone.emptyBlockLightMask = this.emptyBlockLightMask.witClone; + clone.skyLightArrays = this.skyLightArrays.witClone; + clone.blockLightArrays = this.blockLightArrays.witClone; + return clone; + } +} + +/++ + ++/ +struct CLightUpdate { + /++ + + +/ + int chunkX; + + /++ + + +/ + int chunkZ; + + /++ + + +/ + LightData lightData; + + void witFree() @nogc nothrow { + lightData.witFree; + } + + void witDrop() @nogc nothrow { + } + + CLightUpdate witClone() const @nogc nothrow { + CLightUpdate clone = void; + clone.chunkX = this.chunkX.witClone; + clone.chunkZ = this.chunkZ.witClone; + clone.lightData = this.lightData.witClone; + return clone; + } +} + +/++ + ++/ +struct MapIcon { + /++ + + +/ + int iconType; + + /++ + + +/ + ubyte x; + + /++ + + +/ + ubyte z; + + /++ + + +/ + ubyte direction; + + /++ + + +/ + Option!(WitString) displayName; + + void witFree() @nogc nothrow { + displayName.witFree; + } + + void witDrop() @nogc nothrow { + } + + MapIcon witClone() const @nogc nothrow { + MapIcon clone = void; + clone.iconType = this.iconType.witClone; + clone.x = this.x.witClone; + clone.z = this.z.witClone; + clone.direction = this.direction.witClone; + clone.displayName = this.displayName.witClone; + return clone; + } +} + +/++ + ++/ +struct MapPatch { + /++ + + +/ + ubyte columns; + + /++ + + +/ + ubyte rows; + + /++ + + +/ + ubyte x; + + /++ + + +/ + ubyte z; + + /++ + + +/ + WitList!(ubyte) data; + + void witFree() @nogc nothrow { + data.witFree; + } + + void witDrop() @nogc nothrow { + } + + MapPatch witClone() const @nogc nothrow { + MapPatch clone = void; + clone.columns = this.columns.witClone; + clone.rows = this.rows.witClone; + clone.x = this.x.witClone; + clone.z = this.z.witClone; + clone.data = this.data.witClone; + return clone; + } +} + +/++ + ++/ +struct CMapItemData { + /++ + + +/ + int mapId; + + /++ + + +/ + ubyte scale; + + /++ + + +/ + bool trackingPosition; + + /++ + + +/ + bool locked; + + /++ + + +/ + Option!(WitList!(MapIcon)) icons; + + /++ + + +/ + Option!(MapPatch) data; + + void witFree() @nogc nothrow { + icons.witFree; + data.witFree; + } + + void witDrop() @nogc nothrow { + } + + CMapItemData witClone() const @nogc nothrow { + CMapItemData clone = void; + clone.mapId = this.mapId.witClone; + clone.scale = this.scale.witClone; + clone.trackingPosition = this.trackingPosition.witClone; + clone.locked = this.locked.witClone; + clone.icons = this.icons.witClone; + clone.data = this.data.witClone; + return clone; + } +} + +/++ + ++/ +struct MerchantOffer { + /++ + + +/ + WitString baseCostA; + + /++ + + +/ + WitString output; + + /++ + + +/ + Option!(WitString) costB; + + /++ + + +/ + bool rewardExp; + + /++ + + +/ + int uses; + + /++ + + +/ + int maxUses; + + /++ + + +/ + int xp; + + /++ + + +/ + int specialPrice; + + /++ + + +/ + float priceMultiplier; + + /++ + + +/ + int demand; + + void witFree() @nogc nothrow { + baseCostA.witFree; + output.witFree; + costB.witFree; + } + + void witDrop() @nogc nothrow { + } + + MerchantOffer witClone() const @nogc nothrow { + MerchantOffer clone = void; + clone.baseCostA = this.baseCostA.witClone; + clone.output = this.output.witClone; + clone.costB = this.costB.witClone; + clone.rewardExp = this.rewardExp.witClone; + clone.uses = this.uses.witClone; + clone.maxUses = this.maxUses.witClone; + clone.xp = this.xp.witClone; + clone.specialPrice = this.specialPrice.witClone; + clone.priceMultiplier = this.priceMultiplier.witClone; + clone.demand = this.demand.witClone; + return clone; + } +} + +/++ + ++/ +struct CMerchantOffers { + /++ + + +/ + int windowId; + + /++ + + +/ + WitList!(MerchantOffer) offers; + + /++ + + +/ + int villagerLevel; + + /++ + + +/ + int experience; + + /++ + + +/ + bool isRegularVillager; + + /++ + + +/ + bool canRestock; + + void witFree() @nogc nothrow { + offers.witFree; + } + + void witDrop() @nogc nothrow { + } + + CMerchantOffers witClone() const @nogc nothrow { + CMerchantOffers clone = void; + clone.windowId = this.windowId.witClone; + clone.offers = this.offers.witClone; + clone.villagerLevel = this.villagerLevel.witClone; + clone.experience = this.experience.witClone; + clone.isRegularVillager = this.isRegularVillager.witClone; + clone.canRestock = this.canRestock.witClone; + return clone; + } +} + +/++ + ++/ +struct MinecartStep { + /++ + + +/ + Tuple!(double, double, double) position; + + /++ + + +/ + Tuple!(double, double, double) movement; + + /++ + + +/ + float yaw; + + /++ + + +/ + float pitch; + + /++ + + +/ + float weight; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + MinecartStep witClone() const @nogc nothrow { + MinecartStep clone = void; + clone.position = this.position.witClone; + clone.movement = this.movement.witClone; + clone.yaw = this.yaw.witClone; + clone.pitch = this.pitch.witClone; + clone.weight = this.weight.witClone; + return clone; + } +} + +/++ + ++/ +struct CMoveMinecartAlongTrack { + /++ + + +/ + int entityId; + + /++ + + +/ + WitList!(MinecartStep) steps; + + void witFree() @nogc nothrow { + steps.witFree; + } + + void witDrop() @nogc nothrow { + } + + CMoveMinecartAlongTrack witClone() const @nogc nothrow { + CMoveMinecartAlongTrack clone = void; + clone.entityId = this.entityId.witClone; + clone.steps = this.steps.witClone; + return clone; + } +} + +/++ + ++/ +struct CMoveVehicle { + /++ + + +/ + double x; + + /++ + + +/ + double y; + + /++ + + +/ + double z; + + /++ + + +/ + float yaw; + + /++ + + +/ + float pitch; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CMoveVehicle witClone() const @nogc nothrow { + CMoveVehicle clone = void; + clone.x = this.x.witClone; + clone.y = this.y.witClone; + clone.z = this.z.witClone; + clone.yaw = this.yaw.witClone; + clone.pitch = this.pitch.witClone; + return clone; + } +} + +/++ + ++/ +struct CMultiBlockUpdate { + /++ + + +/ + Tuple!(double, double, double) chunkSection; + + /++ + + +/ + bool suppressLightUpdates; + + /++ + + +/ + WitList!(Tuple!(Tuple!(int, int, int), WitString)) updates; + + void witFree() @nogc nothrow { + updates.witFree; + } + + void witDrop() @nogc nothrow { + } + + CMultiBlockUpdate witClone() const @nogc nothrow { + CMultiBlockUpdate clone = void; + clone.chunkSection = this.chunkSection.witClone; + clone.suppressLightUpdates = this.suppressLightUpdates.witClone; + clone.updates = this.updates.witClone; + return clone; + } +} + +/++ + ++/ +struct COpenBook { + /++ + + +/ + int hand; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + COpenBook witClone() const @nogc nothrow { + COpenBook clone = void; + clone.hand = this.hand.witClone; + return clone; + } +} + +/++ + ++/ +struct COpenMountScreen { + /++ + + +/ + ubyte windowId; + + /++ + + +/ + int slotCount; + + /++ + + +/ + int entityId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + COpenMountScreen witClone() const @nogc nothrow { + COpenMountScreen clone = void; + clone.windowId = this.windowId.witClone; + clone.slotCount = this.slotCount.witClone; + clone.entityId = this.entityId.witClone; + return clone; + } +} + +/++ + ++/ +struct COpenScreen { + /++ + + +/ + int syncId; + + /++ + + +/ + int windowType; + + /++ + + +/ + WitString windowTitle; + + void witFree() @nogc nothrow { + windowTitle.witFree; + } + + void witDrop() @nogc nothrow { + } + + COpenScreen witClone() const @nogc nothrow { + COpenScreen clone = void; + clone.syncId = this.syncId.witClone; + clone.windowType = this.windowType.witClone; + clone.windowTitle = this.windowTitle.witClone; + return clone; + } +} + +/++ + ++/ +struct COpenSignEditor { + /++ + + +/ + Tuple!(int, int, int) location; + + /++ + + +/ + bool isFrontText; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + COpenSignEditor witClone() const @nogc nothrow { + COpenSignEditor clone = void; + clone.location = this.location.witClone; + clone.isFrontText = this.isFrontText.witClone; + return clone; + } +} + +/++ + ++/ +struct CParticle { + /++ + + +/ + bool forceSpawn; + + /++ + + +/ + bool important; + + /++ + + +/ + Tuple!(double, double, double) position; + + /++ + + +/ + Tuple!(double, double, double) offset; + + /++ + + +/ + float maxSpeed; + + /++ + + +/ + int particleCount; + + /++ + + +/ + int particleId; + + /++ + + +/ + WitList!(ubyte) data; + + void witFree() @nogc nothrow { + data.witFree; + } + + void witDrop() @nogc nothrow { + } + + CParticle witClone() const @nogc nothrow { + CParticle clone = void; + clone.forceSpawn = this.forceSpawn.witClone; + clone.important = this.important.witClone; + clone.position = this.position.witClone; + clone.offset = this.offset.witClone; + clone.maxSpeed = this.maxSpeed.witClone; + clone.particleCount = this.particleCount.witClone; + clone.particleId = this.particleId.witClone; + clone.data = this.data.witClone; + return clone; + } +} + +/++ + ++/ +struct CPlayPing { + /++ + + +/ + int id; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CPlayPing witClone() const @nogc nothrow { + CPlayPing clone = void; + clone.id = this.id.witClone; + return clone; + } +} + +/++ + ++/ +struct CPingResponse { + /++ + + +/ + long payload; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CPingResponse witClone() const @nogc nothrow { + CPingResponse clone = void; + clone.payload = this.payload.witClone; + return clone; + } +} + +/++ + ++/ +struct CPlaceGhostRecipe { + /++ + + +/ + ubyte windowId; + + /++ + + +/ + WitString recipeId; + + void witFree() @nogc nothrow { + recipeId.witFree; + } + + void witDrop() @nogc nothrow { + } + + CPlaceGhostRecipe witClone() const @nogc nothrow { + CPlaceGhostRecipe clone = void; + clone.windowId = this.windowId.witClone; + clone.recipeId = this.recipeId.witClone; + return clone; + } +} + +/++ + ++/ +struct CPlayerAbilities { + /++ + + +/ + ubyte flags; + + /++ + + +/ + float flyingSpeed; + + /++ + + +/ + float fieldOfView; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CPlayerAbilities witClone() const @nogc nothrow { + CPlayerAbilities clone = void; + clone.flags = this.flags.witClone; + clone.flyingSpeed = this.flyingSpeed.witClone; + clone.fieldOfView = this.fieldOfView.witClone; + return clone; + } +} + +/++ + ++/ +struct InitChat { + /++ + + +/ + Uuid sessionId; + + /++ + + +/ + long expiresAt; + + /++ + + +/ + WitList!(ubyte) publicKey; + + /++ + + +/ + WitList!(ubyte) signature; + + void witFree() @nogc nothrow { + publicKey.witFree; + signature.witFree; + } + + void witDrop() @nogc nothrow { + } + + InitChat witClone() const @nogc nothrow { + InitChat clone = void; + clone.sessionId = this.sessionId.witClone; + clone.expiresAt = this.expiresAt.witClone; + clone.publicKey = this.publicKey.witClone; + clone.signature = this.signature.witClone; + return clone; + } +} + +/++ + ++/ +struct PreviousMessage { + /++ + + +/ + int id; + + /++ + + +/ + Option!(WitList!(ubyte)) signature; + + void witFree() @nogc nothrow { + signature.witFree; + } + + void witDrop() @nogc nothrow { + } + + PreviousMessage witClone() const @nogc nothrow { + PreviousMessage clone = void; + clone.id = this.id.witClone; + clone.signature = this.signature.witClone; + return clone; + } +} + +/++ + ++/ +struct FilterType { + mixin WitVariant!( + void, // passThrough + void, // fullyFiltered + WitList!(long), // partiallyFiltered + ); + +public: + enum Tag : ubyte { + /++ + + +/ + passThrough, + + /++ + + +/ + fullyFiltered, + + /++ + + +/ + partiallyFiltered, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias passThrough = _create!(Tag.passThrough); + /// ditto + pragma(inline, true) bool isPassThrough() const => _tag == Tag.passThrough; + + /++ + + +/ + alias fullyFiltered = _create!(Tag.fullyFiltered); + /// ditto + pragma(inline, true) bool isFullyFiltered() const => _tag == Tag.fullyFiltered; + + /++ + + +/ + alias partiallyFiltered = _create!(Tag.partiallyFiltered); + /// ditto + pragma(inline, true) bool isPartiallyFiltered() const => _tag == Tag.partiallyFiltered; + ///ditto + alias getPartiallyFiltered = _get!(Tag.partiallyFiltered); + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case partiallyFiltered: _get!(Tag.partiallyFiltered).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + } + + FilterType witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.passThrough: return _create!(Tag.passThrough); break; + case Tag.fullyFiltered: return _create!(Tag.fullyFiltered); break; + case Tag.partiallyFiltered: return _create!(Tag.partiallyFiltered)(this._get!(Tag.partiallyFiltered).witClone); break; + } + } +} + +/++ + ++/ +struct CPlayerChatMessage { + /++ + + +/ + int globalIndex; + + /++ + + +/ + Uuid sender; + + /++ + + +/ + int index; + + /++ + + +/ + Option!(WitList!(ubyte)) messageSignature; + + /++ + + +/ + WitString message; + + /++ + + +/ + long timestamp; + + /++ + + +/ + long salt; + + /++ + + +/ + WitList!(PreviousMessage) previousMessages; + + /++ + + +/ + Option!(WitString) unsignedContent; + + /++ + + +/ + FilterType filterType; + + /++ + + +/ + int chatType; + + /++ + + +/ + WitString senderName; + + /++ + + +/ + Option!(WitString) targetName; + + void witFree() @nogc nothrow { + messageSignature.witFree; + message.witFree; + previousMessages.witFree; + unsignedContent.witFree; + filterType.witFree; + senderName.witFree; + targetName.witFree; + } + + void witDrop() @nogc nothrow { + } + + CPlayerChatMessage witClone() const @nogc nothrow { + CPlayerChatMessage clone = void; + clone.globalIndex = this.globalIndex.witClone; + clone.sender = this.sender.witClone; + clone.index = this.index.witClone; + clone.messageSignature = this.messageSignature.witClone; + clone.message = this.message.witClone; + clone.timestamp = this.timestamp.witClone; + clone.salt = this.salt.witClone; + clone.previousMessages = this.previousMessages.witClone; + clone.unsignedContent = this.unsignedContent.witClone; + clone.filterType = this.filterType.witClone; + clone.chatType = this.chatType.witClone; + clone.senderName = this.senderName.witClone; + clone.targetName = this.targetName.witClone; + return clone; + } +} + +/++ + ++/ +struct CPlayerLookAt { + /++ + + +/ + int fromAnchor; + + /++ + + +/ + double targetX; + + /++ + + +/ + double targetY; + + /++ + + +/ + double targetZ; + + /++ + + +/ + Option!(Tuple!(int, int)) entity; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CPlayerLookAt witClone() const @nogc nothrow { + CPlayerLookAt clone = void; + clone.fromAnchor = this.fromAnchor.witClone; + clone.targetX = this.targetX.witClone; + clone.targetY = this.targetY.witClone; + clone.targetZ = this.targetZ.witClone; + clone.entity = this.entity.witClone; + return clone; + } +} + +/++ + ++/ +struct CPlayerPosition { + /++ + + +/ + int teleportId; + + /++ + + +/ + Tuple!(double, double, double) position; + + /++ + + +/ + Tuple!(double, double, double) delta; + + /++ + + +/ + float yaw; + + /++ + + +/ + float pitch; + + /++ + + +/ + WitList!(WitString) relatives; + + void witFree() @nogc nothrow { + relatives.witFree; + } + + void witDrop() @nogc nothrow { + } + + CPlayerPosition witClone() const @nogc nothrow { + CPlayerPosition clone = void; + clone.teleportId = this.teleportId.witClone; + clone.position = this.position.witClone; + clone.delta = this.delta.witClone; + clone.yaw = this.yaw.witClone; + clone.pitch = this.pitch.witClone; + clone.relatives = this.relatives.witClone; + return clone; + } +} + +/++ + ++/ +struct CRemovePlayerInfo { + /++ + + +/ + WitList!(Uuid) players; + + void witFree() @nogc nothrow { + players.witFree; + } + + void witDrop() @nogc nothrow { + } + + CRemovePlayerInfo witClone() const @nogc nothrow { + CRemovePlayerInfo clone = void; + clone.players = this.players.witClone; + return clone; + } +} + +/++ + ++/ +struct CPlayerRotation { + /++ + + +/ + float yaw; + + /++ + + +/ + float pitch; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CPlayerRotation witClone() const @nogc nothrow { + CPlayerRotation clone = void; + clone.yaw = this.yaw.witClone; + clone.pitch = this.pitch.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerSpawnData { + /++ + + +/ + WitString dimension; + + /++ + + +/ + long hashedSeed; + + /++ + + +/ + ubyte gameMode; + + /++ + + +/ + ubyte previousGamemode; + + /++ + + +/ + bool debug_; + + /++ + + +/ + bool isFlat; + + /++ + + +/ + Option!(Tuple!(WitString, Tuple!(int, int, int))) deathDimensionName; + + /++ + + +/ + int portalCooldown; + + /++ + + +/ + int sealevel; + + void witFree() @nogc nothrow { + dimension.witFree; + deathDimensionName.witFree; + } + + void witDrop() @nogc nothrow { + } + + PlayerSpawnData witClone() const @nogc nothrow { + PlayerSpawnData clone = void; + clone.dimension = this.dimension.witClone; + clone.hashedSeed = this.hashedSeed.witClone; + clone.gameMode = this.gameMode.witClone; + clone.previousGamemode = this.previousGamemode.witClone; + clone.debug_ = this.debug_.witClone; + clone.isFlat = this.isFlat.witClone; + clone.deathDimensionName = this.deathDimensionName.witClone; + clone.portalCooldown = this.portalCooldown.witClone; + clone.sealevel = this.sealevel.witClone; + return clone; + } +} + +/++ + ++/ +struct CLogin { + /++ + + +/ + int entityId; + + /++ + + +/ + bool isHardcore; + + /++ + + +/ + WitList!(WitString) dimensionNames; + + /++ + + +/ + int maxPlayers; + + /++ + + +/ + int viewDistance; + + /++ + + +/ + int simulatedDistance; + + /++ + + +/ + bool reducedDebugInfo; + + /++ + + +/ + bool enabledRespawnScreen; + + /++ + + +/ + bool limitedCrafting; + + /++ + + +/ + PlayerSpawnData spawnData; + + /++ + + +/ + bool onlineMode; + + /++ + + +/ + bool enforceSecureChat; + + void witFree() @nogc nothrow { + dimensionNames.witFree; + spawnData.witFree; + } + + void witDrop() @nogc nothrow { + } + + CLogin witClone() const @nogc nothrow { + CLogin clone = void; + clone.entityId = this.entityId.witClone; + clone.isHardcore = this.isHardcore.witClone; + clone.dimensionNames = this.dimensionNames.witClone; + clone.maxPlayers = this.maxPlayers.witClone; + clone.viewDistance = this.viewDistance.witClone; + clone.simulatedDistance = this.simulatedDistance.witClone; + clone.reducedDebugInfo = this.reducedDebugInfo.witClone; + clone.enabledRespawnScreen = this.enabledRespawnScreen.witClone; + clone.limitedCrafting = this.limitedCrafting.witClone; + clone.spawnData = this.spawnData.witClone; + clone.onlineMode = this.onlineMode.witClone; + clone.enforceSecureChat = this.enforceSecureChat.witClone; + return clone; + } +} + +/++ + ++/ +struct CPlayerSpawnPosition { + /++ + + +/ + WitString dimensionName; + + /++ + + +/ + Tuple!(int, int, int) location; + + /++ + + +/ + float yaw; + + /++ + + +/ + float pitch; + + void witFree() @nogc nothrow { + dimensionName.witFree; + } + + void witDrop() @nogc nothrow { + } + + CPlayerSpawnPosition witClone() const @nogc nothrow { + CPlayerSpawnPosition clone = void; + clone.dimensionName = this.dimensionName.witClone; + clone.location = this.location.witClone; + clone.yaw = this.yaw.witClone; + clone.pitch = this.pitch.witClone; + return clone; + } +} + +/++ + ++/ +struct CProjectilePower { + /++ + + +/ + int entityId; + + /++ + + +/ + double xPower; + + /++ + + +/ + double yPower; + + /++ + + +/ + double zPower; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CProjectilePower witClone() const @nogc nothrow { + CProjectilePower clone = void; + clone.entityId = this.entityId.witClone; + clone.xPower = this.xPower.witClone; + clone.yPower = this.yPower.witClone; + clone.zPower = this.zPower.witClone; + return clone; + } +} + +/++ + ++/ +struct CRecipeBookAdd { + /++ + + +/ + bool replace; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CRecipeBookAdd witClone() const @nogc nothrow { + CRecipeBookAdd clone = void; + clone.replace = this.replace.witClone; + return clone; + } +} + +/++ + ++/ +struct CRecipeBookRemove { + /++ + + +/ + WitList!(int) recipes; + + void witFree() @nogc nothrow { + recipes.witFree; + } + + void witDrop() @nogc nothrow { + } + + CRecipeBookRemove witClone() const @nogc nothrow { + CRecipeBookRemove clone = void; + clone.recipes = this.recipes.witClone; + return clone; + } +} + +/++ + ++/ +struct CRecipeBookSettings { + /++ + + +/ + bool craftingOpen; + + /++ + + +/ + bool craftingFiltering; + + /++ + + +/ + bool furnaceOpen; + + /++ + + +/ + bool furnaceFiltering; + + /++ + + +/ + bool blastFurnaceOpen; + + /++ + + +/ + bool blastFurnaceFiltering; + + /++ + + +/ + bool smokerOpen; + + /++ + + +/ + bool smokerFiltering; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CRecipeBookSettings witClone() const @nogc nothrow { + CRecipeBookSettings clone = void; + clone.craftingOpen = this.craftingOpen.witClone; + clone.craftingFiltering = this.craftingFiltering.witClone; + clone.furnaceOpen = this.furnaceOpen.witClone; + clone.furnaceFiltering = this.furnaceFiltering.witClone; + clone.blastFurnaceOpen = this.blastFurnaceOpen.witClone; + clone.blastFurnaceFiltering = this.blastFurnaceFiltering.witClone; + clone.smokerOpen = this.smokerOpen.witClone; + clone.smokerFiltering = this.smokerFiltering.witClone; + return clone; + } +} + +/++ + ++/ +struct CRemoveEntities { + /++ + + +/ + WitList!(int) entityIds; + + void witFree() @nogc nothrow { + entityIds.witFree; + } + + void witDrop() @nogc nothrow { + } + + CRemoveEntities witClone() const @nogc nothrow { + CRemoveEntities clone = void; + clone.entityIds = this.entityIds.witClone; + return clone; + } +} + +/++ + ++/ +struct CRemoveMobEffect { + /++ + + +/ + int entityId; + + /++ + + +/ + int effectId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CRemoveMobEffect witClone() const @nogc nothrow { + CRemoveMobEffect clone = void; + clone.entityId = this.entityId.witClone; + clone.effectId = this.effectId.witClone; + return clone; + } +} + +/++ + ++/ +struct CRemoveResourcePack { + /++ + + +/ + Option!(Uuid) uuid; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CRemoveResourcePack witClone() const @nogc nothrow { + CRemoveResourcePack clone = void; + clone.uuid = this.uuid.witClone; + return clone; + } +} + +/++ + ++/ +struct CResetScore { + /++ + + +/ + WitString entityName; + + /++ + + +/ + Option!(WitString) objectiveName; + + void witFree() @nogc nothrow { + entityName.witFree; + objectiveName.witFree; + } + + void witDrop() @nogc nothrow { + } + + CResetScore witClone() const @nogc nothrow { + CResetScore clone = void; + clone.entityName = this.entityName.witClone; + clone.objectiveName = this.objectiveName.witClone; + return clone; + } +} + +/++ + ++/ +struct CRespawn { + /++ + + +/ + PlayerSpawnData playerSpawnInfo; + + /++ + + +/ + ubyte dataKept; + + void witFree() @nogc nothrow { + playerSpawnInfo.witFree; + } + + void witDrop() @nogc nothrow { + } + + CRespawn witClone() const @nogc nothrow { + CRespawn clone = void; + clone.playerSpawnInfo = this.playerSpawnInfo.witClone; + clone.dataKept = this.dataKept.witClone; + return clone; + } +} + +/++ + ++/ +struct CSelectAdvancementsTab { + /++ + + +/ + Option!(WitString) tabId; + + void witFree() @nogc nothrow { + tabId.witFree; + } + + void witDrop() @nogc nothrow { + } + + CSelectAdvancementsTab witClone() const @nogc nothrow { + CSelectAdvancementsTab clone = void; + clone.tabId = this.tabId.witClone; + return clone; + } +} + +/++ + ++/ +struct CServerData { + /++ + + +/ + WitString motd; + + /++ + + +/ + Option!(WitString) iconBase64; + + void witFree() @nogc nothrow { + motd.witFree; + iconBase64.witFree; + } + + void witDrop() @nogc nothrow { + } + + CServerData witClone() const @nogc nothrow { + CServerData clone = void; + clone.motd = this.motd.witClone; + clone.iconBase64 = this.iconBase64.witClone; + return clone; + } +} + +/++ + ++/ +struct CPlayServerLinks { + /++ + + +/ + WitList!(WitString) links; + + void witFree() @nogc nothrow { + links.witFree; + } + + void witDrop() @nogc nothrow { + } + + CPlayServerLinks witClone() const @nogc nothrow { + CPlayServerLinks clone = void; + clone.links = this.links.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetBorderCenter { + /++ + + +/ + double x; + + /++ + + +/ + double z; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CSetBorderCenter witClone() const @nogc nothrow { + CSetBorderCenter clone = void; + clone.x = this.x.witClone; + clone.z = this.z.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetBorderLerpSize { + /++ + + +/ + double oldDiameter; + + /++ + + +/ + double newDiameter; + + /++ + + +/ + long speed; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CSetBorderLerpSize witClone() const @nogc nothrow { + CSetBorderLerpSize clone = void; + clone.oldDiameter = this.oldDiameter.witClone; + clone.newDiameter = this.newDiameter.witClone; + clone.speed = this.speed.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetBorderSize { + /++ + + +/ + double diameter; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CSetBorderSize witClone() const @nogc nothrow { + CSetBorderSize clone = void; + clone.diameter = this.diameter.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetBorderWarningDelay { + /++ + + +/ + int warningTime; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CSetBorderWarningDelay witClone() const @nogc nothrow { + CSetBorderWarningDelay clone = void; + clone.warningTime = this.warningTime.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetBorderWarningDistance { + /++ + + +/ + int warningBlocks; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CSetBorderWarningDistance witClone() const @nogc nothrow { + CSetBorderWarningDistance clone = void; + clone.warningBlocks = this.warningBlocks.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetCamera { + /++ + + +/ + int cameraId; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CSetCamera witClone() const @nogc nothrow { + CSetCamera clone = void; + clone.cameraId = this.cameraId.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetChunkCacheRadius { + /++ + + +/ + int radius; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CSetChunkCacheRadius witClone() const @nogc nothrow { + CSetChunkCacheRadius clone = void; + clone.radius = this.radius.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetContainerContent { + /++ + + +/ + int windowId; + + /++ + + +/ + int stateId; + + /++ + + +/ + WitList!(WitString) slotData; + + /++ + + +/ + WitString carriedItem; + + void witFree() @nogc nothrow { + slotData.witFree; + carriedItem.witFree; + } + + void witDrop() @nogc nothrow { + } + + CSetContainerContent witClone() const @nogc nothrow { + CSetContainerContent clone = void; + clone.windowId = this.windowId.witClone; + clone.stateId = this.stateId.witClone; + clone.slotData = this.slotData.witClone; + clone.carriedItem = this.carriedItem.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetContainerProperty { + /++ + + +/ + int windowId; + + /++ + + +/ + int property; + + /++ + + +/ + int value; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CSetContainerProperty witClone() const @nogc nothrow { + CSetContainerProperty clone = void; + clone.windowId = this.windowId.witClone; + clone.property = this.property.witClone; + clone.value = this.value.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetContainerSlot { + /++ + + +/ + ubyte windowId; + + /++ + + +/ + int stateId; + + /++ + + +/ + int slot; + + /++ + + +/ + WitString slotData; + + void witFree() @nogc nothrow { + slotData.witFree; + } + + void witDrop() @nogc nothrow { + } + + CSetContainerSlot witClone() const @nogc nothrow { + CSetContainerSlot clone = void; + clone.windowId = this.windowId.witClone; + clone.stateId = this.stateId.witClone; + clone.slot = this.slot.witClone; + clone.slotData = this.slotData.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetCursorItem { + /++ + + +/ + WitString stack; + + void witFree() @nogc nothrow { + stack.witFree; + } + + void witDrop() @nogc nothrow { + } + + CSetCursorItem witClone() const @nogc nothrow { + CSetCursorItem clone = void; + clone.stack = this.stack.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetEntityLink { + /++ + + +/ + int attachedEntityId; + + /++ + + +/ + int holdingEntityId; + + /++ + + +/ + bool leash; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CSetEntityLink witClone() const @nogc nothrow { + CSetEntityLink clone = void; + clone.attachedEntityId = this.attachedEntityId.witClone; + clone.holdingEntityId = this.holdingEntityId.witClone; + clone.leash = this.leash.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetEquipment { + /++ + + +/ + int entityId; + + /++ + + +/ + WitList!(Tuple!(ubyte, WitString)) equipment; + + void witFree() @nogc nothrow { + equipment.witFree; + } + + void witDrop() @nogc nothrow { + } + + CSetEquipment witClone() const @nogc nothrow { + CSetEquipment clone = void; + clone.entityId = this.entityId.witClone; + clone.equipment = this.equipment.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetExperience { + /++ + + +/ + float progress; + + /++ + + +/ + int level; + + /++ + + +/ + int totalExperience; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CSetExperience witClone() const @nogc nothrow { + CSetExperience clone = void; + clone.progress = this.progress.witClone; + clone.level = this.level.witClone; + clone.totalExperience = this.totalExperience.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetHealth { + /++ + + +/ + float health; + + /++ + + +/ + int food; + + /++ + + +/ + float foodSaturation; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CSetHealth witClone() const @nogc nothrow { + CSetHealth clone = void; + clone.health = this.health.witClone; + clone.food = this.food.witClone; + clone.foodSaturation = this.foodSaturation.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetSelectedSlot { + /++ + + +/ + ubyte slot; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CSetSelectedSlot witClone() const @nogc nothrow { + CSetSelectedSlot clone = void; + clone.slot = this.slot.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetPassengers { + /++ + + +/ + int entityId; + + /++ + + +/ + WitList!(int) passengers; + + void witFree() @nogc nothrow { + passengers.witFree; + } + + void witDrop() @nogc nothrow { + } + + CSetPassengers witClone() const @nogc nothrow { + CSetPassengers clone = void; + clone.entityId = this.entityId.witClone; + clone.passengers = this.passengers.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetPlayerInventory { + /++ + + +/ + int slot; + + /++ + + +/ + WitString item; + + void witFree() @nogc nothrow { + item.witFree; + } + + void witDrop() @nogc nothrow { + } + + CSetPlayerInventory witClone() const @nogc nothrow { + CSetPlayerInventory clone = void; + clone.slot = this.slot.witClone; + clone.item = this.item.witClone; + return clone; + } +} + +/++ + ++/ +enum TeamMethod : ubyte { + /++ + + +/ + create, + + /++ + + +/ + remove, + + /++ + + +/ + update, + + /++ + + +/ + addPlayers, + + /++ + + +/ + removePlayers, +} +/++ + ++/ +struct TeamParameters { + /++ + + +/ + WitString displayName; + + /++ + + +/ + ubyte options; + + /++ + + +/ + WitString nametagVisibility; + + /++ + + +/ + WitString collisionRule; + + /++ + + +/ + int color; + + /++ + + +/ + WitString playerPrefix; + + /++ + + +/ + WitString playerSuffix; + + void witFree() @nogc nothrow { + displayName.witFree; + nametagVisibility.witFree; + collisionRule.witFree; + playerPrefix.witFree; + playerSuffix.witFree; + } + + void witDrop() @nogc nothrow { + } + + TeamParameters witClone() const @nogc nothrow { + TeamParameters clone = void; + clone.displayName = this.displayName.witClone; + clone.options = this.options.witClone; + clone.nametagVisibility = this.nametagVisibility.witClone; + clone.collisionRule = this.collisionRule.witClone; + clone.color = this.color.witClone; + clone.playerPrefix = this.playerPrefix.witClone; + clone.playerSuffix = this.playerSuffix.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetPlayerTeam { + /++ + + +/ + WitString teamName; + + /++ + + +/ + TeamMethod method; + + /++ + + +/ + Option!(TeamParameters) parameters; + + /++ + + +/ + WitList!(WitString) players; + + void witFree() @nogc nothrow { + teamName.witFree; + parameters.witFree; + players.witFree; + } + + void witDrop() @nogc nothrow { + } + + CSetPlayerTeam witClone() const @nogc nothrow { + CSetPlayerTeam clone = void; + clone.teamName = this.teamName.witClone; + clone.method = this.method.witClone; + clone.parameters = this.parameters.witClone; + clone.players = this.players.witClone; + return clone; + } +} + +/++ + ++/ +struct CSetSimulationDistance { + /++ + + +/ + int simulationDistance; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CSetSimulationDistance witClone() const @nogc nothrow { + CSetSimulationDistance clone = void; + clone.simulationDistance = this.simulationDistance.witClone; + return clone; + } +} + +/++ + ++/ +struct CUpdateTime { + /++ + + +/ + long gameTime; + + /++ + + +/ + WitList!(Tuple!(int, long, float, float)) clockUpdates; + + void witFree() @nogc nothrow { + clockUpdates.witFree; + } + + void witDrop() @nogc nothrow { + } + + CUpdateTime witClone() const @nogc nothrow { + CUpdateTime clone = void; + clone.gameTime = this.gameTime.witClone; + clone.clockUpdates = this.clockUpdates.witClone; + return clone; + } +} + +/++ + ++/ +struct CTitleText { + /++ + + +/ + WitString title; + + void witFree() @nogc nothrow { + title.witFree; + } + + void witDrop() @nogc nothrow { + } + + CTitleText witClone() const @nogc nothrow { + CTitleText clone = void; + clone.title = this.title.witClone; + return clone; + } +} + +/++ + ++/ +struct CTitleAnimation { + /++ + + +/ + int fadeInTicks; + + /++ + + +/ + int stayTicks; + + /++ + + +/ + int fadeOutTicks; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CTitleAnimation witClone() const @nogc nothrow { + CTitleAnimation clone = void; + clone.fadeInTicks = this.fadeInTicks.witClone; + clone.stayTicks = this.stayTicks.witClone; + clone.fadeOutTicks = this.fadeOutTicks.witClone; + return clone; + } +} + +/++ + ++/ +struct CPlayShowDialog { + /++ + + +/ + WitString dialog; + + void witFree() @nogc nothrow { + dialog.witFree; + } + + void witDrop() @nogc nothrow { + } + + CPlayShowDialog witClone() const @nogc nothrow { + CPlayShowDialog clone = void; + clone.dialog = this.dialog.witClone; + return clone; + } +} + +/++ + ++/ +struct CSoundEffect { + /++ + + +/ + WitString soundEvent; + + /++ + + +/ + int soundCategory; + + /++ + + +/ + Tuple!(double, double, double) position; + + /++ + + +/ + float volume; + + /++ + + +/ + float pitch; + + /++ + + +/ + double seed; + + void witFree() @nogc nothrow { + soundEvent.witFree; + } + + void witDrop() @nogc nothrow { + } + + CSoundEffect witClone() const @nogc nothrow { + CSoundEffect clone = void; + clone.soundEvent = this.soundEvent.witClone; + clone.soundCategory = this.soundCategory.witClone; + clone.position = this.position.witClone; + clone.volume = this.volume.witClone; + clone.pitch = this.pitch.witClone; + clone.seed = this.seed.witClone; + return clone; + } +} + +/++ + ++/ +struct CSpawnEntity { + /++ + + +/ + int entityId; + + /++ + + +/ + Uuid entityUuid; + + /++ + + +/ + int rType; + + /++ + + +/ + Tuple!(double, double, double) position; + + /++ + + +/ + WitString velocity; + + /++ + + +/ + ubyte pitch; + + /++ + + +/ + ubyte yaw; + + /++ + + +/ + ubyte headYaw; + + /++ + + +/ + int data; + + void witFree() @nogc nothrow { + velocity.witFree; + } + + void witDrop() @nogc nothrow { + } + + CSpawnEntity witClone() const @nogc nothrow { + CSpawnEntity clone = void; + clone.entityId = this.entityId.witClone; + clone.entityUuid = this.entityUuid.witClone; + clone.rType = this.rType.witClone; + clone.position = this.position.witClone; + clone.velocity = this.velocity.witClone; + clone.pitch = this.pitch.witClone; + clone.yaw = this.yaw.witClone; + clone.headYaw = this.headYaw.witClone; + clone.data = this.data.witClone; + return clone; + } +} + +/++ + ++/ +struct CSpawnLivingEntity { + /++ + + +/ + int entityId; + + /++ + + +/ + Uuid entityUuid; + + /++ + + +/ + int rType; + + /++ + + +/ + Tuple!(double, double, double) position; + + /++ + + +/ + ubyte yaw; + + /++ + + +/ + ubyte pitch; + + /++ + + +/ + ubyte headYaw; + + /++ + + +/ + WitString velocity; + + /++ + + +/ + Option!(WitList!(ubyte)) metadata; + + void witFree() @nogc nothrow { + velocity.witFree; + metadata.witFree; + } + + void witDrop() @nogc nothrow { + } + + CSpawnLivingEntity witClone() const @nogc nothrow { + CSpawnLivingEntity clone = void; + clone.entityId = this.entityId.witClone; + clone.entityUuid = this.entityUuid.witClone; + clone.rType = this.rType.witClone; + clone.position = this.position.witClone; + clone.yaw = this.yaw.witClone; + clone.pitch = this.pitch.witClone; + clone.headYaw = this.headYaw.witClone; + clone.velocity = this.velocity.witClone; + clone.metadata = this.metadata.witClone; + return clone; + } +} + +/++ + ++/ +struct CSpawnPainting { + /++ + + +/ + int entityId; + + /++ + + +/ + Uuid uuid; + + /++ + + +/ + WitString title; + + /++ + + +/ + int variant; + + /++ + + +/ + Tuple!(int, int, int) location; + + /++ + + +/ + ubyte direction; + + void witFree() @nogc nothrow { + title.witFree; + } + + void witDrop() @nogc nothrow { + } + + CSpawnPainting witClone() const @nogc nothrow { + CSpawnPainting clone = void; + clone.entityId = this.entityId.witClone; + clone.uuid = this.uuid.witClone; + clone.title = this.title.witClone; + clone.variant = this.variant.witClone; + clone.location = this.location.witClone; + clone.direction = this.direction.witClone; + return clone; + } +} + +/++ + ++/ +struct CStopSound { + /++ + + +/ + Option!(WitString) soundId; + + /++ + + +/ + Option!(WitString) category; + + void witFree() @nogc nothrow { + soundId.witFree; + category.witFree; + } + + void witDrop() @nogc nothrow { + } + + CStopSound witClone() const @nogc nothrow { + CStopSound clone = void; + clone.soundId = this.soundId.witClone; + clone.category = this.category.witClone; + return clone; + } +} + +/++ + ++/ +struct CStoreCookie { + /++ + + +/ + WitString key; + + /++ + + +/ + WitList!(ubyte) payload; + + void witFree() @nogc nothrow { + key.witFree; + payload.witFree; + } + + void witDrop() @nogc nothrow { + } + + CStoreCookie witClone() const @nogc nothrow { + CStoreCookie clone = void; + clone.key = this.key.witClone; + clone.payload = this.payload.witClone; + return clone; + } +} + +/++ + ++/ +struct CSubtitle { + /++ + + +/ + WitString subtitle; + + void witFree() @nogc nothrow { + subtitle.witFree; + } + + void witDrop() @nogc nothrow { + } + + CSubtitle witClone() const @nogc nothrow { + CSubtitle clone = void; + clone.subtitle = this.subtitle.witClone; + return clone; + } +} + +/++ + ++/ +struct CSystemChatMessage { + /++ + + +/ + WitString content; + + /++ + + +/ + bool overlay; + + void witFree() @nogc nothrow { + content.witFree; + } + + void witDrop() @nogc nothrow { + } + + CSystemChatMessage witClone() const @nogc nothrow { + CSystemChatMessage clone = void; + clone.content = this.content.witClone; + clone.overlay = this.overlay.witClone; + return clone; + } +} + +/++ + ++/ +struct CTabList { + /++ + + +/ + WitString header; + + /++ + + +/ + WitString footer; + + void witFree() @nogc nothrow { + header.witFree; + footer.witFree; + } + + void witDrop() @nogc nothrow { + } + + CTabList witClone() const @nogc nothrow { + CTabList clone = void; + clone.header = this.header.witClone; + clone.footer = this.footer.witClone; + return clone; + } +} + +/++ + ++/ +struct CTagQueryResponse { + /++ + + +/ + int transactionId; + + /++ + + +/ + WitList!(ubyte) nbtBytes; + + void witFree() @nogc nothrow { + nbtBytes.witFree; + } + + void witDrop() @nogc nothrow { + } + + CTagQueryResponse witClone() const @nogc nothrow { + CTagQueryResponse clone = void; + clone.transactionId = this.transactionId.witClone; + clone.nbtBytes = this.nbtBytes.witClone; + return clone; + } +} + +/++ + ++/ +struct CTakeItemEntity { + /++ + + +/ + int entityId; + + /++ + + +/ + int collectorEntityId; + + /++ + + +/ + int stackAmount; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CTakeItemEntity witClone() const @nogc nothrow { + CTakeItemEntity clone = void; + clone.entityId = this.entityId.witClone; + clone.collectorEntityId = this.collectorEntityId.witClone; + clone.stackAmount = this.stackAmount.witClone; + return clone; + } +} + +/++ + ++/ +struct CTeleportEntity { + /++ + + +/ + int entityId; + + /++ + + +/ + Tuple!(double, double, double) position; + + /++ + + +/ + Tuple!(double, double, double) delta; + + /++ + + +/ + float yaw; + + /++ + + +/ + float pitch; + + /++ + + +/ + WitList!(WitString) relatives; + + /++ + + +/ + bool onGround; + + void witFree() @nogc nothrow { + relatives.witFree; + } + + void witDrop() @nogc nothrow { + } + + CTeleportEntity witClone() const @nogc nothrow { + CTeleportEntity clone = void; + clone.entityId = this.entityId.witClone; + clone.position = this.position.witClone; + clone.delta = this.delta.witClone; + clone.yaw = this.yaw.witClone; + clone.pitch = this.pitch.witClone; + clone.relatives = this.relatives.witClone; + clone.onGround = this.onGround.witClone; + return clone; + } +} + +/++ + ++/ +struct CTestInstanceBlockStatus { + /++ + + +/ + Tuple!(int, int, int) pos; + + /++ + + +/ + int status; + + /++ + + +/ + Option!(WitString) message; + + void witFree() @nogc nothrow { + message.witFree; + } + + void witDrop() @nogc nothrow { + } + + CTestInstanceBlockStatus witClone() const @nogc nothrow { + CTestInstanceBlockStatus clone = void; + clone.pos = this.pos.witClone; + clone.status = this.status.witClone; + clone.message = this.message.witClone; + return clone; + } +} + +/++ + ++/ +struct CTickingState { + /++ + + +/ + float tickRate; + + /++ + + +/ + bool isFrozen; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CTickingState witClone() const @nogc nothrow { + CTickingState clone = void; + clone.tickRate = this.tickRate.witClone; + clone.isFrozen = this.isFrozen.witClone; + return clone; + } +} + +/++ + ++/ +struct CTickingStep { + /++ + + +/ + int tickSteps; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CTickingStep witClone() const @nogc nothrow { + CTickingStep clone = void; + clone.tickSteps = this.tickSteps.witClone; + return clone; + } +} + +/++ + ++/ +struct CTransfer { + /++ + + +/ + WitString host; + + /++ + + +/ + int port; + + void witFree() @nogc nothrow { + host.witFree; + } + + void witDrop() @nogc nothrow { + } + + CTransfer witClone() const @nogc nothrow { + CTransfer clone = void; + clone.host = this.host.witClone; + clone.port = this.port.witClone; + return clone; + } +} + +/++ + ++/ +struct CUnloadChunk { + /++ + + +/ + int x; + + /++ + + +/ + int z; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CUnloadChunk witClone() const @nogc nothrow { + CUnloadChunk clone = void; + clone.x = this.x.witClone; + clone.z = this.z.witClone; + return clone; + } +} + +/++ + ++/ +struct CUpdateAdvancements { + /++ + + +/ + bool reset; + + /++ + + +/ + WitList!(WitString) added; + + /++ + + +/ + WitList!(WitString) removed; + + /++ + + +/ + WitList!(WitString) progress; + + /++ + + +/ + bool showAdvancements; + + void witFree() @nogc nothrow { + added.witFree; + removed.witFree; + progress.witFree; + } + + void witDrop() @nogc nothrow { + } + + CUpdateAdvancements witClone() const @nogc nothrow { + CUpdateAdvancements clone = void; + clone.reset = this.reset.witClone; + clone.added = this.added.witClone; + clone.removed = this.removed.witClone; + clone.progress = this.progress.witClone; + clone.showAdvancements = this.showAdvancements.witClone; + return clone; + } +} + +/++ + ++/ +struct AttributeModifier { + /++ + + +/ + WitString id; + + /++ + + +/ + double amount; + + /++ + + +/ + ubyte operation; + + void witFree() @nogc nothrow { + id.witFree; + } + + void witDrop() @nogc nothrow { + } + + AttributeModifier witClone() const @nogc nothrow { + AttributeModifier clone = void; + clone.id = this.id.witClone; + clone.amount = this.amount.witClone; + clone.operation = this.operation.witClone; + return clone; + } +} + +/++ + ++/ +struct Property { + /++ + + +/ + int id; + + /++ + + +/ + double value; + + /++ + + +/ + WitList!(AttributeModifier) modifiers; + + void witFree() @nogc nothrow { + modifiers.witFree; + } + + void witDrop() @nogc nothrow { + } + + Property witClone() const @nogc nothrow { + Property clone = void; + clone.id = this.id.witClone; + clone.value = this.value.witClone; + clone.modifiers = this.modifiers.witClone; + return clone; + } +} + +/++ + ++/ +struct CLoginSuccess { + /++ + + +/ + Uuid uuid; + + /++ + + +/ + WitString username; + + /++ + + +/ + WitList!(Property) properties; + + /++ + + +/ + bool strictErrorHandling; + + /++ + + +/ + Uuid sessionId; + + void witFree() @nogc nothrow { + username.witFree; + properties.witFree; + } + + void witDrop() @nogc nothrow { + } + + CLoginSuccess witClone() const @nogc nothrow { + CLoginSuccess clone = void; + clone.uuid = this.uuid.witClone; + clone.username = this.username.witClone; + clone.properties = this.properties.witClone; + clone.strictErrorHandling = this.strictErrorHandling.witClone; + clone.sessionId = this.sessionId.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerActionAddPlayer { + /++ + + +/ + WitString name; + + /++ + + +/ + WitList!(Property) properties; + + void witFree() @nogc nothrow { + name.witFree; + properties.witFree; + } + + void witDrop() @nogc nothrow { + } + + PlayerActionAddPlayer witClone() const @nogc nothrow { + PlayerActionAddPlayer clone = void; + clone.name = this.name.witClone; + clone.properties = this.properties.witClone; + return clone; + } +} + +/++ + ++/ +struct PlayerAction { + mixin WitVariant!( + PlayerActionAddPlayer, // addPlayer + Option!(InitChat), // initializeChat + int, // updateGameMode + bool, // updateListed + int, // updateLatency + Option!(WitString), // updateDisplayName + int, // updateListOrder + bool, // updateHat + ); + +public: + enum Tag : ubyte { + /++ + + +/ + addPlayer, + + /++ + + +/ + initializeChat, + + /++ + + +/ + updateGameMode, + + /++ + + +/ + updateListed, + + /++ + + +/ + updateLatency, + + /++ + + +/ + updateDisplayName, + + /++ + + +/ + updateListOrder, + + /++ + + +/ + updateHat, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias addPlayer = _create!(Tag.addPlayer); + /// ditto + pragma(inline, true) bool isAddPlayer() const => _tag == Tag.addPlayer; + ///ditto + alias getAddPlayer = _get!(Tag.addPlayer); + + /++ + + +/ + alias initializeChat = _create!(Tag.initializeChat); + /// ditto + pragma(inline, true) bool isInitializeChat() const => _tag == Tag.initializeChat; + ///ditto + alias getInitializeChat = _get!(Tag.initializeChat); + + /++ + + +/ + alias updateGameMode = _create!(Tag.updateGameMode); + /// ditto + pragma(inline, true) bool isUpdateGameMode() const => _tag == Tag.updateGameMode; + ///ditto + alias getUpdateGameMode = _get!(Tag.updateGameMode); + + /++ + + +/ + alias updateListed = _create!(Tag.updateListed); + /// ditto + pragma(inline, true) bool isUpdateListed() const => _tag == Tag.updateListed; + ///ditto + alias getUpdateListed = _get!(Tag.updateListed); + + /++ + + +/ + alias updateLatency = _create!(Tag.updateLatency); + /// ditto + pragma(inline, true) bool isUpdateLatency() const => _tag == Tag.updateLatency; + ///ditto + alias getUpdateLatency = _get!(Tag.updateLatency); + + /++ + + +/ + alias updateDisplayName = _create!(Tag.updateDisplayName); + /// ditto + pragma(inline, true) bool isUpdateDisplayName() const => _tag == Tag.updateDisplayName; + ///ditto + alias getUpdateDisplayName = _get!(Tag.updateDisplayName); + + /++ + + +/ + alias updateListOrder = _create!(Tag.updateListOrder); + /// ditto + pragma(inline, true) bool isUpdateListOrder() const => _tag == Tag.updateListOrder; + ///ditto + alias getUpdateListOrder = _get!(Tag.updateListOrder); + + /++ + + +/ + alias updateHat = _create!(Tag.updateHat); + /// ditto + pragma(inline, true) bool isUpdateHat() const => _tag == Tag.updateHat; + ///ditto + alias getUpdateHat = _get!(Tag.updateHat); + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case addPlayer: _get!(Tag.addPlayer).witFree; break; + case initializeChat: _get!(Tag.initializeChat).witFree; break; + case updateDisplayName: _get!(Tag.updateDisplayName).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + } + + PlayerAction witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.addPlayer: return _create!(Tag.addPlayer)(this._get!(Tag.addPlayer).witClone); break; + case Tag.initializeChat: return _create!(Tag.initializeChat)(this._get!(Tag.initializeChat).witClone); break; + case Tag.updateGameMode: return _create!(Tag.updateGameMode)(this._get!(Tag.updateGameMode).witClone); break; + case Tag.updateListed: return _create!(Tag.updateListed)(this._get!(Tag.updateListed).witClone); break; + case Tag.updateLatency: return _create!(Tag.updateLatency)(this._get!(Tag.updateLatency).witClone); break; + case Tag.updateDisplayName: return _create!(Tag.updateDisplayName)(this._get!(Tag.updateDisplayName).witClone); break; + case Tag.updateListOrder: return _create!(Tag.updateListOrder)(this._get!(Tag.updateListOrder).witClone); break; + case Tag.updateHat: return _create!(Tag.updateHat)(this._get!(Tag.updateHat).witClone); break; + } + } +} + +/++ + ++/ +struct Player { + /++ + + +/ + Uuid uuid; + + /++ + + +/ + WitList!(PlayerAction) actions; + + void witFree() @nogc nothrow { + actions.witFree; + } + + void witDrop() @nogc nothrow { + } + + Player witClone() const @nogc nothrow { + Player clone = void; + clone.uuid = this.uuid.witClone; + clone.actions = this.actions.witClone; + return clone; + } +} + +/++ + ++/ +struct CPlayerInfoUpdate { + /++ + + +/ + ubyte actions; + + /++ + + +/ + WitList!(Player) players; + + void witFree() @nogc nothrow { + players.witFree; + } + + void witDrop() @nogc nothrow { + } + + CPlayerInfoUpdate witClone() const @nogc nothrow { + CPlayerInfoUpdate clone = void; + clone.actions = this.actions.witClone; + clone.players = this.players.witClone; + return clone; + } +} + +/++ + ++/ +struct CUpdateAttributes { + /++ + + +/ + int entityId; + + /++ + + +/ + WitList!(Property) properties; + + void witFree() @nogc nothrow { + properties.witFree; + } + + void witDrop() @nogc nothrow { + } + + CUpdateAttributes witClone() const @nogc nothrow { + CUpdateAttributes clone = void; + clone.entityId = this.entityId.witClone; + clone.properties = this.properties.witClone; + return clone; + } +} + +/++ + ++/ +struct CUpdateEntityPos { + /++ + + +/ + int entityId; + + /++ + + +/ + Tuple!(double, double, double) delta; + + /++ + + +/ + bool onGround; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CUpdateEntityPos witClone() const @nogc nothrow { + CUpdateEntityPos clone = void; + clone.entityId = this.entityId.witClone; + clone.delta = this.delta.witClone; + clone.onGround = this.onGround.witClone; + return clone; + } +} + +/++ + ++/ +struct CUpdateEntityPosRot { + /++ + + +/ + int entityId; + + /++ + + +/ + Tuple!(double, double, double) delta; + + /++ + + +/ + ubyte yaw; + + /++ + + +/ + ubyte pitch; + + /++ + + +/ + bool onGround; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CUpdateEntityPosRot witClone() const @nogc nothrow { + CUpdateEntityPosRot clone = void; + clone.entityId = this.entityId.witClone; + clone.delta = this.delta.witClone; + clone.yaw = this.yaw.witClone; + clone.pitch = this.pitch.witClone; + clone.onGround = this.onGround.witClone; + return clone; + } +} + +/++ + ++/ +struct CUpdateEntityRot { + /++ + + +/ + int entityId; + + /++ + + +/ + ubyte yaw; + + /++ + + +/ + ubyte pitch; + + /++ + + +/ + bool onGround; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CUpdateEntityRot witClone() const @nogc nothrow { + CUpdateEntityRot clone = void; + clone.entityId = this.entityId.witClone; + clone.yaw = this.yaw.witClone; + clone.pitch = this.pitch.witClone; + clone.onGround = this.onGround.witClone; + return clone; + } +} + +/++ + ++/ +struct CUpdateMobEffect { + /++ + + +/ + int entityId; + + /++ + + +/ + int effectId; + + /++ + + +/ + int amplifier; + + /++ + + +/ + int duration; + + /++ + + +/ + ubyte flags; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CUpdateMobEffect witClone() const @nogc nothrow { + CUpdateMobEffect clone = void; + clone.entityId = this.entityId.witClone; + clone.effectId = this.effectId.witClone; + clone.amplifier = this.amplifier.witClone; + clone.duration = this.duration.witClone; + clone.flags = this.flags.witClone; + return clone; + } +} + +/++ + ++/ +struct CUpdateObjectives { + /++ + + +/ + WitString objectiveName; + + /++ + + +/ + ubyte mode; + + /++ + + +/ + WitString displayName; + + /++ + + +/ + int renderType; + + /++ + + +/ + Option!(WitString) numberFormat; + + void witFree() @nogc nothrow { + objectiveName.witFree; + displayName.witFree; + numberFormat.witFree; + } + + void witDrop() @nogc nothrow { + } + + CUpdateObjectives witClone() const @nogc nothrow { + CUpdateObjectives clone = void; + clone.objectiveName = this.objectiveName.witClone; + clone.mode = this.mode.witClone; + clone.displayName = this.displayName.witClone; + clone.renderType = this.renderType.witClone; + clone.numberFormat = this.numberFormat.witClone; + return clone; + } +} + +/++ + ++/ +enum Mode : ubyte { + /++ + + +/ + add, + + /++ + + +/ + remove, + + /++ + + +/ + update, +} +/++ + ++/ +enum RenderType : ubyte { + /++ + + +/ + integer, + + /++ + + +/ + hearts, +} +/++ + ++/ +struct CUpdateRecipes { + /++ + + +/ + WitList!(ubyte) rawData; + + void witFree() @nogc nothrow { + rawData.witFree; + } + + void witDrop() @nogc nothrow { + } + + CUpdateRecipes witClone() const @nogc nothrow { + CUpdateRecipes clone = void; + clone.rawData = this.rawData.witClone; + return clone; + } +} + +/++ + ++/ +struct CUpdateScore { + /++ + + +/ + WitString entityName; + + /++ + + +/ + WitString objectiveName; + + /++ + + +/ + int value; + + /++ + + +/ + Option!(WitString) displayName; + + /++ + + +/ + Option!(WitString) numberFormat; + + void witFree() @nogc nothrow { + entityName.witFree; + objectiveName.witFree; + displayName.witFree; + numberFormat.witFree; + } + + void witDrop() @nogc nothrow { + } + + CUpdateScore witClone() const @nogc nothrow { + CUpdateScore clone = void; + clone.entityName = this.entityName.witClone; + clone.objectiveName = this.objectiveName.witClone; + clone.value = this.value.witClone; + clone.displayName = this.displayName.witClone; + clone.numberFormat = this.numberFormat.witClone; + return clone; + } +} + +/++ + ++/ +struct CUpdateTagsPlay { + /++ + + +/ + WitList!(WitString) tags; + + void witFree() @nogc nothrow { + tags.witFree; + } + + void witDrop() @nogc nothrow { + } + + CUpdateTagsPlay witClone() const @nogc nothrow { + CUpdateTagsPlay clone = void; + clone.tags = this.tags.witClone; + return clone; + } +} + +/++ + ++/ +struct CUseBed { + /++ + + +/ + int entityId; + + /++ + + +/ + Tuple!(int, int, int) location; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CUseBed witClone() const @nogc nothrow { + CUseBed clone = void; + clone.entityId = this.entityId.witClone; + clone.location = this.location.witClone; + return clone; + } +} + +/++ + ++/ +enum WaypointOperation : ubyte { + /++ + + +/ + track, + + /++ + + +/ + untrack, + + /++ + + +/ + update, +} +/++ + ++/ +struct WaypointTargetChunk { + /++ + + +/ + int x; + + /++ + + +/ + int z; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + WaypointTargetChunk witClone() const @nogc nothrow { + WaypointTargetChunk clone = void; + clone.x = this.x.witClone; + clone.z = this.z.witClone; + return clone; + } +} + +/++ + ++/ +struct WaypointTarget { + mixin WitVariant!( + Tuple!(int, int, int), // position + WaypointTargetChunk, // chunk + float, // azimuth + void, // empty + ); + +public: + enum Tag : ubyte { + /++ + + +/ + position, + + /++ + + +/ + chunk, + + /++ + + +/ + azimuth, + + /++ + + +/ + empty, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias position = _create!(Tag.position); + /// ditto + pragma(inline, true) bool isPosition() const => _tag == Tag.position; + ///ditto + alias getPosition = _get!(Tag.position); + + /++ + + +/ + alias chunk = _create!(Tag.chunk); + /// ditto + pragma(inline, true) bool isChunk() const => _tag == Tag.chunk; + ///ditto + alias getChunk = _get!(Tag.chunk); + + /++ + + +/ + alias azimuth = _create!(Tag.azimuth); + /// ditto + pragma(inline, true) bool isAzimuth() const => _tag == Tag.azimuth; + ///ditto + alias getAzimuth = _get!(Tag.azimuth); + + /++ + + +/ + alias empty = _create!(Tag.empty); + /// ditto + pragma(inline, true) bool isEmpty() const => _tag == Tag.empty; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + WaypointTarget witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.position: return _create!(Tag.position)(this._get!(Tag.position).witClone); break; + case Tag.chunk: return _create!(Tag.chunk)(this._get!(Tag.chunk).witClone); break; + case Tag.azimuth: return _create!(Tag.azimuth)(this._get!(Tag.azimuth).witClone); break; + case Tag.empty: return _create!(Tag.empty); break; + } + } +} + +/++ + ++/ +struct WaypointIcon { + /++ + + +/ + Option!(WitString) style; + + /++ + + +/ + int color; + + void witFree() @nogc nothrow { + style.witFree; + } + + void witDrop() @nogc nothrow { + } + + WaypointIcon witClone() const @nogc nothrow { + WaypointIcon clone = void; + clone.style = this.style.witClone; + clone.color = this.color.witClone; + return clone; + } +} + +/++ + ++/ +struct TrackedWaypoint { + /++ + + +/ + Uuid identifier; + + /++ + + +/ + Option!(WaypointIcon) icon; + + /++ + + +/ + WaypointTarget target; + + void witFree() @nogc nothrow { + icon.witFree; + } + + void witDrop() @nogc nothrow { + } + + TrackedWaypoint witClone() const @nogc nothrow { + TrackedWaypoint clone = void; + clone.identifier = this.identifier.witClone; + clone.icon = this.icon.witClone; + clone.target = this.target.witClone; + return clone; + } +} + +/++ + ++/ +struct CWaypoint { + /++ + + +/ + WaypointOperation operation; + + /++ + + +/ + TrackedWaypoint waypoint; + + void witFree() @nogc nothrow { + waypoint.witFree; + } + + void witDrop() @nogc nothrow { + } + + CWaypoint witClone() const @nogc nothrow { + CWaypoint clone = void; + clone.operation = this.operation.witClone; + clone.waypoint = this.waypoint.witClone; + return clone; + } +} + +/++ + ++/ +struct CWorldEvent { + /++ + + +/ + int event; + + /++ + + +/ + Tuple!(int, int, int) location; + + /++ + + +/ + int data; + + /++ + + +/ + bool disableRelativeVolume; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CWorldEvent witClone() const @nogc nothrow { + CWorldEvent clone = void; + clone.event = this.event.witClone; + clone.location = this.location.witClone; + clone.data = this.data.witClone; + clone.disableRelativeVolume = this.disableRelativeVolume.witClone; + return clone; + } +} + +/++ + ++/ +struct StatusCPingResponse { + /++ + + +/ + long payload; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + StatusCPingResponse witClone() const @nogc nothrow { + StatusCPingResponse clone = void; + clone.payload = this.payload.witClone; + return clone; + } +} + +/++ + ++/ +struct StatusCStatusResponse { + /++ + + +/ + WitString jsonResponse; + + void witFree() @nogc nothrow { + jsonResponse.witFree; + } + + void witDrop() @nogc nothrow { + } + + StatusCStatusResponse witClone() const @nogc nothrow { + StatusCStatusResponse clone = void; + clone.jsonResponse = this.jsonResponse.witClone; + return clone; + } +} + +/++ + ++/ +struct ServerboundPacket { + mixin WitVariant!( + void, // configSAcceptCodeOfConduct + void, // configSAcknowledgeFinishConfig + ConfigSClientInformationConfig, // configSClientInformationConfig + ConfigSConfigCookieResponse, // configSConfigCookieResponse + ConfigSCustomClickAction, // configSCustomClickAction + ConfigSKeepAlive, // configSKeepAlive + ConfigSKnownPacks, // configSKnownPacks + ConfigSPluginMessage, // configSPluginMessage + ConfigSConfigPong, // configSConfigPong + ConfigSConfigResourcePack, // configSConfigResourcePack + LoginSLoginCookieResponse, // loginSLoginCookieResponse + void, // loginSLoginAcknowledged + LoginSLoginStart, // loginSLoginStart + LoginSLoginPluginResponse, // loginSLoginPluginResponse + SAttack, // sAttack + SBlockEntityTagQuery, // sBlockEntityTagQuery + SBundleItemSelected, // sBundleItemSelected + SChangeDifficulty, // sChangeDifficulty + SChangeGameMode, // sChangeGameMode + SChatAck, // sChatAck + SChatCommand, // sChatCommand + SChatCommandSigned, // sChatCommandSigned + SChatMessage, // sChatMessage + SChunkBatch, // sChunkBatch + SClickSlot, // sClickSlot + SClientCommand, // sClientCommand + SClientInformationPlay, // sClientInformationPlay + void, // sClientTickEnd + SCloseContainer, // sCloseContainer + SCommandSuggestion, // sCommandSuggestion + void, // sConfigurationAcknowledged + SContainerButtonClick, // sContainerButtonClick + SContainerSlotStateChanged, // sContainerSlotStateChanged + SCookieResponse, // sCookieResponse + SCustomClickAction, // sCustomClickAction + SCustomPayload, // sCustomPayload + SDebugSampleSubscription, // sDebugSampleSubscription + SDebugSubscriptionRequest, // sDebugSubscriptionRequest + SEditBook, // sEditBook + SEntityTagQuery, // sEntityTagQuery + SInteract, // sInteract + SJigsawGenerate, // sJigsawGenerate + SKeepAlive, // sKeepAlive + SLockDifficulty, // sLockDifficulty + SMoveVehicle, // sMoveVehicle + SPaddleBoat, // sPaddleBoat + SPickItemFromBlock, // sPickItemFromBlock + SPickItemFromEntity, // sPickItemFromEntity + SPlayPingRequest, // sPlayPingRequest + SPlaceRecipe, // sPlaceRecipe + SPlayerAbilities, // sPlayerAbilities + SPlayerAction, // sPlayerAction + SPlayerCommand, // sPlayerCommand + SSetPlayerGround, // sSetPlayerGround + SPlayerInput, // sPlayerInput + void, // sPlayerLoaded + SPlayerPosition, // sPlayerPosition + SPlayerPositionRotation, // sPlayerPositionRotation + SPlayerRotation, // sPlayerRotation + SPlayerSession, // sPlayerSession + SPlayPong, // sPlayPong + SRecipeBookChangeSettings, // sRecipeBookChangeSettings + SRecipeBookSeenRecipe, // sRecipeBookSeenRecipe + SRenameItem, // sRenameItem + SPlayResourcePack, // sPlayResourcePack + SSeenAdvancement, // sSeenAdvancement + SSelectTrade, // sSelectTrade + SSetBeacon, // sSetBeacon + SSetCommandBlock, // sSetCommandBlock + SSetCommandMinecart, // sSetCommandMinecart + SSetCreativeSlot, // sSetCreativeSlot + SSetGameRule, // sSetGameRule + SSetHeldItem, // sSetHeldItem + SSetJigsawBlock, // sSetJigsawBlock + SSetStructureBlock, // sSetStructureBlock + SSetTestBlock, // sSetTestBlock + SSpectateEntity, // sSpectateEntity + SSwingArm, // sSwingArm + STeleportToEntity, // sTeleportToEntity + STestInstanceBlockAction, // sTestInstanceBlockAction + SUpdateSign, // sUpdateSign + SUseItem, // sUseItem + SUseItemOn, // sUseItemOn + StatusSStatusPingRequest, // statusSStatusPingRequest + void, // statusSStatusRequest + void, // unknown + ); + +public: + enum Tag : ubyte { + /++ + + +/ + configSAcceptCodeOfConduct, + + /++ + + +/ + configSAcknowledgeFinishConfig, + + /++ + + +/ + configSClientInformationConfig, + + /++ + + +/ + configSConfigCookieResponse, + + /++ + + +/ + configSCustomClickAction, + + /++ + + +/ + configSKeepAlive, + + /++ + + +/ + configSKnownPacks, + + /++ + + +/ + configSPluginMessage, + + /++ + + +/ + configSConfigPong, + + /++ + + +/ + configSConfigResourcePack, + + /++ + + +/ + loginSLoginCookieResponse, + + /++ + + +/ + loginSLoginAcknowledged, + + /++ + + +/ + loginSLoginStart, + + /++ + + +/ + loginSLoginPluginResponse, + + /++ + + +/ + sAttack, + + /++ + + +/ + sBlockEntityTagQuery, + + /++ + + +/ + sBundleItemSelected, + + /++ + + +/ + sChangeDifficulty, + + /++ + + +/ + sChangeGameMode, + + /++ + + +/ + sChatAck, + + /++ + + +/ + sChatCommand, + + /++ + + +/ + sChatCommandSigned, + + /++ + + +/ + sChatMessage, + + /++ + + +/ + sChunkBatch, + + /++ + + +/ + sClickSlot, + + /++ + + +/ + sClientCommand, + + /++ + + +/ + sClientInformationPlay, + + /++ + + +/ + sClientTickEnd, + + /++ + + +/ + sCloseContainer, + + /++ + + +/ + sCommandSuggestion, + + /++ + + +/ + sConfigurationAcknowledged, + + /++ + + +/ + sContainerButtonClick, + + /++ + + +/ + sContainerSlotStateChanged, + + /++ + + +/ + sCookieResponse, + + /++ + + +/ + sCustomClickAction, + + /++ + + +/ + sCustomPayload, + + /++ + + +/ + sDebugSampleSubscription, + + /++ + + +/ + sDebugSubscriptionRequest, + + /++ + + +/ + sEditBook, + + /++ + + +/ + sEntityTagQuery, + + /++ + + +/ + sInteract, + + /++ + + +/ + sJigsawGenerate, + + /++ + + +/ + sKeepAlive, + + /++ + + +/ + sLockDifficulty, + + /++ + + +/ + sMoveVehicle, + + /++ + + +/ + sPaddleBoat, + + /++ + + +/ + sPickItemFromBlock, + + /++ + + +/ + sPickItemFromEntity, + + /++ + + +/ + sPlayPingRequest, + + /++ + + +/ + sPlaceRecipe, + + /++ + + +/ + sPlayerAbilities, + + /++ + + +/ + sPlayerAction, + + /++ + + +/ + sPlayerCommand, + + /++ + + +/ + sSetPlayerGround, + + /++ + + +/ + sPlayerInput, + + /++ + + +/ + sPlayerLoaded, + + /++ + + +/ + sPlayerPosition, + + /++ + + +/ + sPlayerPositionRotation, + + /++ + + +/ + sPlayerRotation, + + /++ + + +/ + sPlayerSession, + + /++ + + +/ + sPlayPong, + + /++ + + +/ + sRecipeBookChangeSettings, + + /++ + + +/ + sRecipeBookSeenRecipe, + + /++ + + +/ + sRenameItem, + + /++ + + +/ + sPlayResourcePack, + + /++ + + +/ + sSeenAdvancement, + + /++ + + +/ + sSelectTrade, + + /++ + + +/ + sSetBeacon, + + /++ + + +/ + sSetCommandBlock, + + /++ + + +/ + sSetCommandMinecart, + + /++ + + +/ + sSetCreativeSlot, + + /++ + + +/ + sSetGameRule, + + /++ + + +/ + sSetHeldItem, + + /++ + + +/ + sSetJigsawBlock, + + /++ + + +/ + sSetStructureBlock, + + /++ + + +/ + sSetTestBlock, + + /++ + + +/ + sSpectateEntity, + + /++ + + +/ + sSwingArm, + + /++ + + +/ + sTeleportToEntity, + + /++ + + +/ + sTestInstanceBlockAction, + + /++ + + +/ + sUpdateSign, + + /++ + + +/ + sUseItem, + + /++ + + +/ + sUseItemOn, + + /++ + + +/ + statusSStatusPingRequest, + + /++ + + +/ + statusSStatusRequest, + + /++ + + +/ + unknown, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias configSAcceptCodeOfConduct = _create!(Tag.configSAcceptCodeOfConduct); + /// ditto + pragma(inline, true) bool isConfigSAcceptCodeOfConduct() const => _tag == Tag.configSAcceptCodeOfConduct; + + /++ + + +/ + alias configSAcknowledgeFinishConfig = _create!(Tag.configSAcknowledgeFinishConfig); + /// ditto + pragma(inline, true) bool isConfigSAcknowledgeFinishConfig() const => _tag == Tag.configSAcknowledgeFinishConfig; + + /++ + + +/ + alias configSClientInformationConfig = _create!(Tag.configSClientInformationConfig); + /// ditto + pragma(inline, true) bool isConfigSClientInformationConfig() const => _tag == Tag.configSClientInformationConfig; + ///ditto + alias getConfigSClientInformationConfig = _get!(Tag.configSClientInformationConfig); + + /++ + + +/ + alias configSConfigCookieResponse = _create!(Tag.configSConfigCookieResponse); + /// ditto + pragma(inline, true) bool isConfigSConfigCookieResponse() const => _tag == Tag.configSConfigCookieResponse; + ///ditto + alias getConfigSConfigCookieResponse = _get!(Tag.configSConfigCookieResponse); + + /++ + + +/ + alias configSCustomClickAction = _create!(Tag.configSCustomClickAction); + /// ditto + pragma(inline, true) bool isConfigSCustomClickAction() const => _tag == Tag.configSCustomClickAction; + ///ditto + alias getConfigSCustomClickAction = _get!(Tag.configSCustomClickAction); + + /++ + + +/ + alias configSKeepAlive = _create!(Tag.configSKeepAlive); + /// ditto + pragma(inline, true) bool isConfigSKeepAlive() const => _tag == Tag.configSKeepAlive; + ///ditto + alias getConfigSKeepAlive = _get!(Tag.configSKeepAlive); + + /++ + + +/ + alias configSKnownPacks = _create!(Tag.configSKnownPacks); + /// ditto + pragma(inline, true) bool isConfigSKnownPacks() const => _tag == Tag.configSKnownPacks; + ///ditto + alias getConfigSKnownPacks = _get!(Tag.configSKnownPacks); + + /++ + + +/ + alias configSPluginMessage = _create!(Tag.configSPluginMessage); + /// ditto + pragma(inline, true) bool isConfigSPluginMessage() const => _tag == Tag.configSPluginMessage; + ///ditto + alias getConfigSPluginMessage = _get!(Tag.configSPluginMessage); + + /++ + + +/ + alias configSConfigPong = _create!(Tag.configSConfigPong); + /// ditto + pragma(inline, true) bool isConfigSConfigPong() const => _tag == Tag.configSConfigPong; + ///ditto + alias getConfigSConfigPong = _get!(Tag.configSConfigPong); + + /++ + + +/ + alias configSConfigResourcePack = _create!(Tag.configSConfigResourcePack); + /// ditto + pragma(inline, true) bool isConfigSConfigResourcePack() const => _tag == Tag.configSConfigResourcePack; + ///ditto + alias getConfigSConfigResourcePack = _get!(Tag.configSConfigResourcePack); + + /++ + + +/ + alias loginSLoginCookieResponse = _create!(Tag.loginSLoginCookieResponse); + /// ditto + pragma(inline, true) bool isLoginSLoginCookieResponse() const => _tag == Tag.loginSLoginCookieResponse; + ///ditto + alias getLoginSLoginCookieResponse = _get!(Tag.loginSLoginCookieResponse); + + /++ + + +/ + alias loginSLoginAcknowledged = _create!(Tag.loginSLoginAcknowledged); + /// ditto + pragma(inline, true) bool isLoginSLoginAcknowledged() const => _tag == Tag.loginSLoginAcknowledged; + + /++ + + +/ + alias loginSLoginStart = _create!(Tag.loginSLoginStart); + /// ditto + pragma(inline, true) bool isLoginSLoginStart() const => _tag == Tag.loginSLoginStart; + ///ditto + alias getLoginSLoginStart = _get!(Tag.loginSLoginStart); + + /++ + + +/ + alias loginSLoginPluginResponse = _create!(Tag.loginSLoginPluginResponse); + /// ditto + pragma(inline, true) bool isLoginSLoginPluginResponse() const => _tag == Tag.loginSLoginPluginResponse; + ///ditto + alias getLoginSLoginPluginResponse = _get!(Tag.loginSLoginPluginResponse); + + /++ + + +/ + alias sAttack = _create!(Tag.sAttack); + /// ditto + pragma(inline, true) bool isSAttack() const => _tag == Tag.sAttack; + ///ditto + alias getSAttack = _get!(Tag.sAttack); + + /++ + + +/ + alias sBlockEntityTagQuery = _create!(Tag.sBlockEntityTagQuery); + /// ditto + pragma(inline, true) bool isSBlockEntityTagQuery() const => _tag == Tag.sBlockEntityTagQuery; + ///ditto + alias getSBlockEntityTagQuery = _get!(Tag.sBlockEntityTagQuery); + + /++ + + +/ + alias sBundleItemSelected = _create!(Tag.sBundleItemSelected); + /// ditto + pragma(inline, true) bool isSBundleItemSelected() const => _tag == Tag.sBundleItemSelected; + ///ditto + alias getSBundleItemSelected = _get!(Tag.sBundleItemSelected); + + /++ + + +/ + alias sChangeDifficulty = _create!(Tag.sChangeDifficulty); + /// ditto + pragma(inline, true) bool isSChangeDifficulty() const => _tag == Tag.sChangeDifficulty; + ///ditto + alias getSChangeDifficulty = _get!(Tag.sChangeDifficulty); + + /++ + + +/ + alias sChangeGameMode = _create!(Tag.sChangeGameMode); + /// ditto + pragma(inline, true) bool isSChangeGameMode() const => _tag == Tag.sChangeGameMode; + ///ditto + alias getSChangeGameMode = _get!(Tag.sChangeGameMode); + + /++ + + +/ + alias sChatAck = _create!(Tag.sChatAck); + /// ditto + pragma(inline, true) bool isSChatAck() const => _tag == Tag.sChatAck; + ///ditto + alias getSChatAck = _get!(Tag.sChatAck); + + /++ + + +/ + alias sChatCommand = _create!(Tag.sChatCommand); + /// ditto + pragma(inline, true) bool isSChatCommand() const => _tag == Tag.sChatCommand; + ///ditto + alias getSChatCommand = _get!(Tag.sChatCommand); + + /++ + + +/ + alias sChatCommandSigned = _create!(Tag.sChatCommandSigned); + /// ditto + pragma(inline, true) bool isSChatCommandSigned() const => _tag == Tag.sChatCommandSigned; + ///ditto + alias getSChatCommandSigned = _get!(Tag.sChatCommandSigned); + + /++ + + +/ + alias sChatMessage = _create!(Tag.sChatMessage); + /// ditto + pragma(inline, true) bool isSChatMessage() const => _tag == Tag.sChatMessage; + ///ditto + alias getSChatMessage = _get!(Tag.sChatMessage); + + /++ + + +/ + alias sChunkBatch = _create!(Tag.sChunkBatch); + /// ditto + pragma(inline, true) bool isSChunkBatch() const => _tag == Tag.sChunkBatch; + ///ditto + alias getSChunkBatch = _get!(Tag.sChunkBatch); + + /++ + + +/ + alias sClickSlot = _create!(Tag.sClickSlot); + /// ditto + pragma(inline, true) bool isSClickSlot() const => _tag == Tag.sClickSlot; + ///ditto + alias getSClickSlot = _get!(Tag.sClickSlot); + + /++ + + +/ + alias sClientCommand = _create!(Tag.sClientCommand); + /// ditto + pragma(inline, true) bool isSClientCommand() const => _tag == Tag.sClientCommand; + ///ditto + alias getSClientCommand = _get!(Tag.sClientCommand); + + /++ + + +/ + alias sClientInformationPlay = _create!(Tag.sClientInformationPlay); + /// ditto + pragma(inline, true) bool isSClientInformationPlay() const => _tag == Tag.sClientInformationPlay; + ///ditto + alias getSClientInformationPlay = _get!(Tag.sClientInformationPlay); + + /++ + + +/ + alias sClientTickEnd = _create!(Tag.sClientTickEnd); + /// ditto + pragma(inline, true) bool isSClientTickEnd() const => _tag == Tag.sClientTickEnd; + + /++ + + +/ + alias sCloseContainer = _create!(Tag.sCloseContainer); + /// ditto + pragma(inline, true) bool isSCloseContainer() const => _tag == Tag.sCloseContainer; + ///ditto + alias getSCloseContainer = _get!(Tag.sCloseContainer); + + /++ + + +/ + alias sCommandSuggestion = _create!(Tag.sCommandSuggestion); + /// ditto + pragma(inline, true) bool isSCommandSuggestion() const => _tag == Tag.sCommandSuggestion; + ///ditto + alias getSCommandSuggestion = _get!(Tag.sCommandSuggestion); + + /++ + + +/ + alias sConfigurationAcknowledged = _create!(Tag.sConfigurationAcknowledged); + /// ditto + pragma(inline, true) bool isSConfigurationAcknowledged() const => _tag == Tag.sConfigurationAcknowledged; + + /++ + + +/ + alias sContainerButtonClick = _create!(Tag.sContainerButtonClick); + /// ditto + pragma(inline, true) bool isSContainerButtonClick() const => _tag == Tag.sContainerButtonClick; + ///ditto + alias getSContainerButtonClick = _get!(Tag.sContainerButtonClick); + + /++ + + +/ + alias sContainerSlotStateChanged = _create!(Tag.sContainerSlotStateChanged); + /// ditto + pragma(inline, true) bool isSContainerSlotStateChanged() const => _tag == Tag.sContainerSlotStateChanged; + ///ditto + alias getSContainerSlotStateChanged = _get!(Tag.sContainerSlotStateChanged); + + /++ + + +/ + alias sCookieResponse = _create!(Tag.sCookieResponse); + /// ditto + pragma(inline, true) bool isSCookieResponse() const => _tag == Tag.sCookieResponse; + ///ditto + alias getSCookieResponse = _get!(Tag.sCookieResponse); + + /++ + + +/ + alias sCustomClickAction = _create!(Tag.sCustomClickAction); + /// ditto + pragma(inline, true) bool isSCustomClickAction() const => _tag == Tag.sCustomClickAction; + ///ditto + alias getSCustomClickAction = _get!(Tag.sCustomClickAction); + + /++ + + +/ + alias sCustomPayload = _create!(Tag.sCustomPayload); + /// ditto + pragma(inline, true) bool isSCustomPayload() const => _tag == Tag.sCustomPayload; + ///ditto + alias getSCustomPayload = _get!(Tag.sCustomPayload); + + /++ + + +/ + alias sDebugSampleSubscription = _create!(Tag.sDebugSampleSubscription); + /// ditto + pragma(inline, true) bool isSDebugSampleSubscription() const => _tag == Tag.sDebugSampleSubscription; + ///ditto + alias getSDebugSampleSubscription = _get!(Tag.sDebugSampleSubscription); + + /++ + + +/ + alias sDebugSubscriptionRequest = _create!(Tag.sDebugSubscriptionRequest); + /// ditto + pragma(inline, true) bool isSDebugSubscriptionRequest() const => _tag == Tag.sDebugSubscriptionRequest; + ///ditto + alias getSDebugSubscriptionRequest = _get!(Tag.sDebugSubscriptionRequest); + + /++ + + +/ + alias sEditBook = _create!(Tag.sEditBook); + /// ditto + pragma(inline, true) bool isSEditBook() const => _tag == Tag.sEditBook; + ///ditto + alias getSEditBook = _get!(Tag.sEditBook); + + /++ + + +/ + alias sEntityTagQuery = _create!(Tag.sEntityTagQuery); + /// ditto + pragma(inline, true) bool isSEntityTagQuery() const => _tag == Tag.sEntityTagQuery; + ///ditto + alias getSEntityTagQuery = _get!(Tag.sEntityTagQuery); + + /++ + + +/ + alias sInteract = _create!(Tag.sInteract); + /// ditto + pragma(inline, true) bool isSInteract() const => _tag == Tag.sInteract; + ///ditto + alias getSInteract = _get!(Tag.sInteract); + + /++ + + +/ + alias sJigsawGenerate = _create!(Tag.sJigsawGenerate); + /// ditto + pragma(inline, true) bool isSJigsawGenerate() const => _tag == Tag.sJigsawGenerate; + ///ditto + alias getSJigsawGenerate = _get!(Tag.sJigsawGenerate); + + /++ + + +/ + alias sKeepAlive = _create!(Tag.sKeepAlive); + /// ditto + pragma(inline, true) bool isSKeepAlive() const => _tag == Tag.sKeepAlive; + ///ditto + alias getSKeepAlive = _get!(Tag.sKeepAlive); + + /++ + + +/ + alias sLockDifficulty = _create!(Tag.sLockDifficulty); + /// ditto + pragma(inline, true) bool isSLockDifficulty() const => _tag == Tag.sLockDifficulty; + ///ditto + alias getSLockDifficulty = _get!(Tag.sLockDifficulty); + + /++ + + +/ + alias sMoveVehicle = _create!(Tag.sMoveVehicle); + /// ditto + pragma(inline, true) bool isSMoveVehicle() const => _tag == Tag.sMoveVehicle; + ///ditto + alias getSMoveVehicle = _get!(Tag.sMoveVehicle); + + /++ + + +/ + alias sPaddleBoat = _create!(Tag.sPaddleBoat); + /// ditto + pragma(inline, true) bool isSPaddleBoat() const => _tag == Tag.sPaddleBoat; + ///ditto + alias getSPaddleBoat = _get!(Tag.sPaddleBoat); + + /++ + + +/ + alias sPickItemFromBlock = _create!(Tag.sPickItemFromBlock); + /// ditto + pragma(inline, true) bool isSPickItemFromBlock() const => _tag == Tag.sPickItemFromBlock; + ///ditto + alias getSPickItemFromBlock = _get!(Tag.sPickItemFromBlock); + + /++ + + +/ + alias sPickItemFromEntity = _create!(Tag.sPickItemFromEntity); + /// ditto + pragma(inline, true) bool isSPickItemFromEntity() const => _tag == Tag.sPickItemFromEntity; + ///ditto + alias getSPickItemFromEntity = _get!(Tag.sPickItemFromEntity); + + /++ + + +/ + alias sPlayPingRequest = _create!(Tag.sPlayPingRequest); + /// ditto + pragma(inline, true) bool isSPlayPingRequest() const => _tag == Tag.sPlayPingRequest; + ///ditto + alias getSPlayPingRequest = _get!(Tag.sPlayPingRequest); + + /++ + + +/ + alias sPlaceRecipe = _create!(Tag.sPlaceRecipe); + /// ditto + pragma(inline, true) bool isSPlaceRecipe() const => _tag == Tag.sPlaceRecipe; + ///ditto + alias getSPlaceRecipe = _get!(Tag.sPlaceRecipe); + + /++ + + +/ + alias sPlayerAbilities = _create!(Tag.sPlayerAbilities); + /// ditto + pragma(inline, true) bool isSPlayerAbilities() const => _tag == Tag.sPlayerAbilities; + ///ditto + alias getSPlayerAbilities = _get!(Tag.sPlayerAbilities); + + /++ + + +/ + alias sPlayerAction = _create!(Tag.sPlayerAction); + /// ditto + pragma(inline, true) bool isSPlayerAction() const => _tag == Tag.sPlayerAction; + ///ditto + alias getSPlayerAction = _get!(Tag.sPlayerAction); + + /++ + + +/ + alias sPlayerCommand = _create!(Tag.sPlayerCommand); + /// ditto + pragma(inline, true) bool isSPlayerCommand() const => _tag == Tag.sPlayerCommand; + ///ditto + alias getSPlayerCommand = _get!(Tag.sPlayerCommand); + + /++ + + +/ + alias sSetPlayerGround = _create!(Tag.sSetPlayerGround); + /// ditto + pragma(inline, true) bool isSSetPlayerGround() const => _tag == Tag.sSetPlayerGround; + ///ditto + alias getSSetPlayerGround = _get!(Tag.sSetPlayerGround); + + /++ + + +/ + alias sPlayerInput = _create!(Tag.sPlayerInput); + /// ditto + pragma(inline, true) bool isSPlayerInput() const => _tag == Tag.sPlayerInput; + ///ditto + alias getSPlayerInput = _get!(Tag.sPlayerInput); + + /++ + + +/ + alias sPlayerLoaded = _create!(Tag.sPlayerLoaded); + /// ditto + pragma(inline, true) bool isSPlayerLoaded() const => _tag == Tag.sPlayerLoaded; + + /++ + + +/ + alias sPlayerPosition = _create!(Tag.sPlayerPosition); + /// ditto + pragma(inline, true) bool isSPlayerPosition() const => _tag == Tag.sPlayerPosition; + ///ditto + alias getSPlayerPosition = _get!(Tag.sPlayerPosition); + + /++ + + +/ + alias sPlayerPositionRotation = _create!(Tag.sPlayerPositionRotation); + /// ditto + pragma(inline, true) bool isSPlayerPositionRotation() const => _tag == Tag.sPlayerPositionRotation; + ///ditto + alias getSPlayerPositionRotation = _get!(Tag.sPlayerPositionRotation); + + /++ + + +/ + alias sPlayerRotation = _create!(Tag.sPlayerRotation); + /// ditto + pragma(inline, true) bool isSPlayerRotation() const => _tag == Tag.sPlayerRotation; + ///ditto + alias getSPlayerRotation = _get!(Tag.sPlayerRotation); + + /++ + + +/ + alias sPlayerSession = _create!(Tag.sPlayerSession); + /// ditto + pragma(inline, true) bool isSPlayerSession() const => _tag == Tag.sPlayerSession; + ///ditto + alias getSPlayerSession = _get!(Tag.sPlayerSession); + + /++ + + +/ + alias sPlayPong = _create!(Tag.sPlayPong); + /// ditto + pragma(inline, true) bool isSPlayPong() const => _tag == Tag.sPlayPong; + ///ditto + alias getSPlayPong = _get!(Tag.sPlayPong); + + /++ + + +/ + alias sRecipeBookChangeSettings = _create!(Tag.sRecipeBookChangeSettings); + /// ditto + pragma(inline, true) bool isSRecipeBookChangeSettings() const => _tag == Tag.sRecipeBookChangeSettings; + ///ditto + alias getSRecipeBookChangeSettings = _get!(Tag.sRecipeBookChangeSettings); + + /++ + + +/ + alias sRecipeBookSeenRecipe = _create!(Tag.sRecipeBookSeenRecipe); + /// ditto + pragma(inline, true) bool isSRecipeBookSeenRecipe() const => _tag == Tag.sRecipeBookSeenRecipe; + ///ditto + alias getSRecipeBookSeenRecipe = _get!(Tag.sRecipeBookSeenRecipe); + + /++ + + +/ + alias sRenameItem = _create!(Tag.sRenameItem); + /// ditto + pragma(inline, true) bool isSRenameItem() const => _tag == Tag.sRenameItem; + ///ditto + alias getSRenameItem = _get!(Tag.sRenameItem); + + /++ + + +/ + alias sPlayResourcePack = _create!(Tag.sPlayResourcePack); + /// ditto + pragma(inline, true) bool isSPlayResourcePack() const => _tag == Tag.sPlayResourcePack; + ///ditto + alias getSPlayResourcePack = _get!(Tag.sPlayResourcePack); + + /++ + + +/ + alias sSeenAdvancement = _create!(Tag.sSeenAdvancement); + /// ditto + pragma(inline, true) bool isSSeenAdvancement() const => _tag == Tag.sSeenAdvancement; + ///ditto + alias getSSeenAdvancement = _get!(Tag.sSeenAdvancement); + + /++ + + +/ + alias sSelectTrade = _create!(Tag.sSelectTrade); + /// ditto + pragma(inline, true) bool isSSelectTrade() const => _tag == Tag.sSelectTrade; + ///ditto + alias getSSelectTrade = _get!(Tag.sSelectTrade); + + /++ + + +/ + alias sSetBeacon = _create!(Tag.sSetBeacon); + /// ditto + pragma(inline, true) bool isSSetBeacon() const => _tag == Tag.sSetBeacon; + ///ditto + alias getSSetBeacon = _get!(Tag.sSetBeacon); + + /++ + + +/ + alias sSetCommandBlock = _create!(Tag.sSetCommandBlock); + /// ditto + pragma(inline, true) bool isSSetCommandBlock() const => _tag == Tag.sSetCommandBlock; + ///ditto + alias getSSetCommandBlock = _get!(Tag.sSetCommandBlock); + + /++ + + +/ + alias sSetCommandMinecart = _create!(Tag.sSetCommandMinecart); + /// ditto + pragma(inline, true) bool isSSetCommandMinecart() const => _tag == Tag.sSetCommandMinecart; + ///ditto + alias getSSetCommandMinecart = _get!(Tag.sSetCommandMinecart); + + /++ + + +/ + alias sSetCreativeSlot = _create!(Tag.sSetCreativeSlot); + /// ditto + pragma(inline, true) bool isSSetCreativeSlot() const => _tag == Tag.sSetCreativeSlot; + ///ditto + alias getSSetCreativeSlot = _get!(Tag.sSetCreativeSlot); + + /++ + + +/ + alias sSetGameRule = _create!(Tag.sSetGameRule); + /// ditto + pragma(inline, true) bool isSSetGameRule() const => _tag == Tag.sSetGameRule; + ///ditto + alias getSSetGameRule = _get!(Tag.sSetGameRule); + + /++ + + +/ + alias sSetHeldItem = _create!(Tag.sSetHeldItem); + /// ditto + pragma(inline, true) bool isSSetHeldItem() const => _tag == Tag.sSetHeldItem; + ///ditto + alias getSSetHeldItem = _get!(Tag.sSetHeldItem); + + /++ + + +/ + alias sSetJigsawBlock = _create!(Tag.sSetJigsawBlock); + /// ditto + pragma(inline, true) bool isSSetJigsawBlock() const => _tag == Tag.sSetJigsawBlock; + ///ditto + alias getSSetJigsawBlock = _get!(Tag.sSetJigsawBlock); + + /++ + + +/ + alias sSetStructureBlock = _create!(Tag.sSetStructureBlock); + /// ditto + pragma(inline, true) bool isSSetStructureBlock() const => _tag == Tag.sSetStructureBlock; + ///ditto + alias getSSetStructureBlock = _get!(Tag.sSetStructureBlock); + + /++ + + +/ + alias sSetTestBlock = _create!(Tag.sSetTestBlock); + /// ditto + pragma(inline, true) bool isSSetTestBlock() const => _tag == Tag.sSetTestBlock; + ///ditto + alias getSSetTestBlock = _get!(Tag.sSetTestBlock); + + /++ + + +/ + alias sSpectateEntity = _create!(Tag.sSpectateEntity); + /// ditto + pragma(inline, true) bool isSSpectateEntity() const => _tag == Tag.sSpectateEntity; + ///ditto + alias getSSpectateEntity = _get!(Tag.sSpectateEntity); + + /++ + + +/ + alias sSwingArm = _create!(Tag.sSwingArm); + /// ditto + pragma(inline, true) bool isSSwingArm() const => _tag == Tag.sSwingArm; + ///ditto + alias getSSwingArm = _get!(Tag.sSwingArm); + + /++ + + +/ + alias sTeleportToEntity = _create!(Tag.sTeleportToEntity); + /// ditto + pragma(inline, true) bool isSTeleportToEntity() const => _tag == Tag.sTeleportToEntity; + ///ditto + alias getSTeleportToEntity = _get!(Tag.sTeleportToEntity); + + /++ + + +/ + alias sTestInstanceBlockAction = _create!(Tag.sTestInstanceBlockAction); + /// ditto + pragma(inline, true) bool isSTestInstanceBlockAction() const => _tag == Tag.sTestInstanceBlockAction; + ///ditto + alias getSTestInstanceBlockAction = _get!(Tag.sTestInstanceBlockAction); + + /++ + + +/ + alias sUpdateSign = _create!(Tag.sUpdateSign); + /// ditto + pragma(inline, true) bool isSUpdateSign() const => _tag == Tag.sUpdateSign; + ///ditto + alias getSUpdateSign = _get!(Tag.sUpdateSign); + + /++ + + +/ + alias sUseItem = _create!(Tag.sUseItem); + /// ditto + pragma(inline, true) bool isSUseItem() const => _tag == Tag.sUseItem; + ///ditto + alias getSUseItem = _get!(Tag.sUseItem); + + /++ + + +/ + alias sUseItemOn = _create!(Tag.sUseItemOn); + /// ditto + pragma(inline, true) bool isSUseItemOn() const => _tag == Tag.sUseItemOn; + ///ditto + alias getSUseItemOn = _get!(Tag.sUseItemOn); + + /++ + + +/ + alias statusSStatusPingRequest = _create!(Tag.statusSStatusPingRequest); + /// ditto + pragma(inline, true) bool isStatusSStatusPingRequest() const => _tag == Tag.statusSStatusPingRequest; + ///ditto + alias getStatusSStatusPingRequest = _get!(Tag.statusSStatusPingRequest); + + /++ + + +/ + alias statusSStatusRequest = _create!(Tag.statusSStatusRequest); + /// ditto + pragma(inline, true) bool isStatusSStatusRequest() const => _tag == Tag.statusSStatusRequest; + + /++ + + +/ + alias unknown = _create!(Tag.unknown); + /// ditto + pragma(inline, true) bool isUnknown() const => _tag == Tag.unknown; + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case configSClientInformationConfig: _get!(Tag.configSClientInformationConfig).witFree; break; + case configSConfigCookieResponse: _get!(Tag.configSConfigCookieResponse).witFree; break; + case configSCustomClickAction: _get!(Tag.configSCustomClickAction).witFree; break; + case configSKnownPacks: _get!(Tag.configSKnownPacks).witFree; break; + case configSPluginMessage: _get!(Tag.configSPluginMessage).witFree; break; + case loginSLoginCookieResponse: _get!(Tag.loginSLoginCookieResponse).witFree; break; + case loginSLoginStart: _get!(Tag.loginSLoginStart).witFree; break; + case loginSLoginPluginResponse: _get!(Tag.loginSLoginPluginResponse).witFree; break; + case sChangeDifficulty: _get!(Tag.sChangeDifficulty).witFree; break; + case sChangeGameMode: _get!(Tag.sChangeGameMode).witFree; break; + case sChatCommand: _get!(Tag.sChatCommand).witFree; break; + case sChatCommandSigned: _get!(Tag.sChatCommandSigned).witFree; break; + case sChatMessage: _get!(Tag.sChatMessage).witFree; break; + case sClickSlot: _get!(Tag.sClickSlot).witFree; break; + case sClientInformationPlay: _get!(Tag.sClientInformationPlay).witFree; break; + case sCommandSuggestion: _get!(Tag.sCommandSuggestion).witFree; break; + case sCookieResponse: _get!(Tag.sCookieResponse).witFree; break; + case sCustomClickAction: _get!(Tag.sCustomClickAction).witFree; break; + case sCustomPayload: _get!(Tag.sCustomPayload).witFree; break; + case sEditBook: _get!(Tag.sEditBook).witFree; break; + case sPlayerSession: _get!(Tag.sPlayerSession).witFree; break; + case sRenameItem: _get!(Tag.sRenameItem).witFree; break; + case sSeenAdvancement: _get!(Tag.sSeenAdvancement).witFree; break; + case sSetCommandBlock: _get!(Tag.sSetCommandBlock).witFree; break; + case sSetCommandMinecart: _get!(Tag.sSetCommandMinecart).witFree; break; + case sSetCreativeSlot: _get!(Tag.sSetCreativeSlot).witFree; break; + case sSetGameRule: _get!(Tag.sSetGameRule).witFree; break; + case sSetJigsawBlock: _get!(Tag.sSetJigsawBlock).witFree; break; + case sSetStructureBlock: _get!(Tag.sSetStructureBlock).witFree; break; + case sSetTestBlock: _get!(Tag.sSetTestBlock).witFree; break; + case sTestInstanceBlockAction: _get!(Tag.sTestInstanceBlockAction).witFree; break; + case sUpdateSign: _get!(Tag.sUpdateSign).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + } + + ServerboundPacket witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.configSAcceptCodeOfConduct: return _create!(Tag.configSAcceptCodeOfConduct); break; + case Tag.configSAcknowledgeFinishConfig: return _create!(Tag.configSAcknowledgeFinishConfig); break; + case Tag.configSClientInformationConfig: return _create!(Tag.configSClientInformationConfig)(this._get!(Tag.configSClientInformationConfig).witClone); break; + case Tag.configSConfigCookieResponse: return _create!(Tag.configSConfigCookieResponse)(this._get!(Tag.configSConfigCookieResponse).witClone); break; + case Tag.configSCustomClickAction: return _create!(Tag.configSCustomClickAction)(this._get!(Tag.configSCustomClickAction).witClone); break; + case Tag.configSKeepAlive: return _create!(Tag.configSKeepAlive)(this._get!(Tag.configSKeepAlive).witClone); break; + case Tag.configSKnownPacks: return _create!(Tag.configSKnownPacks)(this._get!(Tag.configSKnownPacks).witClone); break; + case Tag.configSPluginMessage: return _create!(Tag.configSPluginMessage)(this._get!(Tag.configSPluginMessage).witClone); break; + case Tag.configSConfigPong: return _create!(Tag.configSConfigPong)(this._get!(Tag.configSConfigPong).witClone); break; + case Tag.configSConfigResourcePack: return _create!(Tag.configSConfigResourcePack)(this._get!(Tag.configSConfigResourcePack).witClone); break; + case Tag.loginSLoginCookieResponse: return _create!(Tag.loginSLoginCookieResponse)(this._get!(Tag.loginSLoginCookieResponse).witClone); break; + case Tag.loginSLoginAcknowledged: return _create!(Tag.loginSLoginAcknowledged); break; + case Tag.loginSLoginStart: return _create!(Tag.loginSLoginStart)(this._get!(Tag.loginSLoginStart).witClone); break; + case Tag.loginSLoginPluginResponse: return _create!(Tag.loginSLoginPluginResponse)(this._get!(Tag.loginSLoginPluginResponse).witClone); break; + case Tag.sAttack: return _create!(Tag.sAttack)(this._get!(Tag.sAttack).witClone); break; + case Tag.sBlockEntityTagQuery: return _create!(Tag.sBlockEntityTagQuery)(this._get!(Tag.sBlockEntityTagQuery).witClone); break; + case Tag.sBundleItemSelected: return _create!(Tag.sBundleItemSelected)(this._get!(Tag.sBundleItemSelected).witClone); break; + case Tag.sChangeDifficulty: return _create!(Tag.sChangeDifficulty)(this._get!(Tag.sChangeDifficulty).witClone); break; + case Tag.sChangeGameMode: return _create!(Tag.sChangeGameMode)(this._get!(Tag.sChangeGameMode).witClone); break; + case Tag.sChatAck: return _create!(Tag.sChatAck)(this._get!(Tag.sChatAck).witClone); break; + case Tag.sChatCommand: return _create!(Tag.sChatCommand)(this._get!(Tag.sChatCommand).witClone); break; + case Tag.sChatCommandSigned: return _create!(Tag.sChatCommandSigned)(this._get!(Tag.sChatCommandSigned).witClone); break; + case Tag.sChatMessage: return _create!(Tag.sChatMessage)(this._get!(Tag.sChatMessage).witClone); break; + case Tag.sChunkBatch: return _create!(Tag.sChunkBatch)(this._get!(Tag.sChunkBatch).witClone); break; + case Tag.sClickSlot: return _create!(Tag.sClickSlot)(this._get!(Tag.sClickSlot).witClone); break; + case Tag.sClientCommand: return _create!(Tag.sClientCommand)(this._get!(Tag.sClientCommand).witClone); break; + case Tag.sClientInformationPlay: return _create!(Tag.sClientInformationPlay)(this._get!(Tag.sClientInformationPlay).witClone); break; + case Tag.sClientTickEnd: return _create!(Tag.sClientTickEnd); break; + case Tag.sCloseContainer: return _create!(Tag.sCloseContainer)(this._get!(Tag.sCloseContainer).witClone); break; + case Tag.sCommandSuggestion: return _create!(Tag.sCommandSuggestion)(this._get!(Tag.sCommandSuggestion).witClone); break; + case Tag.sConfigurationAcknowledged: return _create!(Tag.sConfigurationAcknowledged); break; + case Tag.sContainerButtonClick: return _create!(Tag.sContainerButtonClick)(this._get!(Tag.sContainerButtonClick).witClone); break; + case Tag.sContainerSlotStateChanged: return _create!(Tag.sContainerSlotStateChanged)(this._get!(Tag.sContainerSlotStateChanged).witClone); break; + case Tag.sCookieResponse: return _create!(Tag.sCookieResponse)(this._get!(Tag.sCookieResponse).witClone); break; + case Tag.sCustomClickAction: return _create!(Tag.sCustomClickAction)(this._get!(Tag.sCustomClickAction).witClone); break; + case Tag.sCustomPayload: return _create!(Tag.sCustomPayload)(this._get!(Tag.sCustomPayload).witClone); break; + case Tag.sDebugSampleSubscription: return _create!(Tag.sDebugSampleSubscription)(this._get!(Tag.sDebugSampleSubscription).witClone); break; + case Tag.sDebugSubscriptionRequest: return _create!(Tag.sDebugSubscriptionRequest)(this._get!(Tag.sDebugSubscriptionRequest).witClone); break; + case Tag.sEditBook: return _create!(Tag.sEditBook)(this._get!(Tag.sEditBook).witClone); break; + case Tag.sEntityTagQuery: return _create!(Tag.sEntityTagQuery)(this._get!(Tag.sEntityTagQuery).witClone); break; + case Tag.sInteract: return _create!(Tag.sInteract)(this._get!(Tag.sInteract).witClone); break; + case Tag.sJigsawGenerate: return _create!(Tag.sJigsawGenerate)(this._get!(Tag.sJigsawGenerate).witClone); break; + case Tag.sKeepAlive: return _create!(Tag.sKeepAlive)(this._get!(Tag.sKeepAlive).witClone); break; + case Tag.sLockDifficulty: return _create!(Tag.sLockDifficulty)(this._get!(Tag.sLockDifficulty).witClone); break; + case Tag.sMoveVehicle: return _create!(Tag.sMoveVehicle)(this._get!(Tag.sMoveVehicle).witClone); break; + case Tag.sPaddleBoat: return _create!(Tag.sPaddleBoat)(this._get!(Tag.sPaddleBoat).witClone); break; + case Tag.sPickItemFromBlock: return _create!(Tag.sPickItemFromBlock)(this._get!(Tag.sPickItemFromBlock).witClone); break; + case Tag.sPickItemFromEntity: return _create!(Tag.sPickItemFromEntity)(this._get!(Tag.sPickItemFromEntity).witClone); break; + case Tag.sPlayPingRequest: return _create!(Tag.sPlayPingRequest)(this._get!(Tag.sPlayPingRequest).witClone); break; + case Tag.sPlaceRecipe: return _create!(Tag.sPlaceRecipe)(this._get!(Tag.sPlaceRecipe).witClone); break; + case Tag.sPlayerAbilities: return _create!(Tag.sPlayerAbilities)(this._get!(Tag.sPlayerAbilities).witClone); break; + case Tag.sPlayerAction: return _create!(Tag.sPlayerAction)(this._get!(Tag.sPlayerAction).witClone); break; + case Tag.sPlayerCommand: return _create!(Tag.sPlayerCommand)(this._get!(Tag.sPlayerCommand).witClone); break; + case Tag.sSetPlayerGround: return _create!(Tag.sSetPlayerGround)(this._get!(Tag.sSetPlayerGround).witClone); break; + case Tag.sPlayerInput: return _create!(Tag.sPlayerInput)(this._get!(Tag.sPlayerInput).witClone); break; + case Tag.sPlayerLoaded: return _create!(Tag.sPlayerLoaded); break; + case Tag.sPlayerPosition: return _create!(Tag.sPlayerPosition)(this._get!(Tag.sPlayerPosition).witClone); break; + case Tag.sPlayerPositionRotation: return _create!(Tag.sPlayerPositionRotation)(this._get!(Tag.sPlayerPositionRotation).witClone); break; + case Tag.sPlayerRotation: return _create!(Tag.sPlayerRotation)(this._get!(Tag.sPlayerRotation).witClone); break; + case Tag.sPlayerSession: return _create!(Tag.sPlayerSession)(this._get!(Tag.sPlayerSession).witClone); break; + case Tag.sPlayPong: return _create!(Tag.sPlayPong)(this._get!(Tag.sPlayPong).witClone); break; + case Tag.sRecipeBookChangeSettings: return _create!(Tag.sRecipeBookChangeSettings)(this._get!(Tag.sRecipeBookChangeSettings).witClone); break; + case Tag.sRecipeBookSeenRecipe: return _create!(Tag.sRecipeBookSeenRecipe)(this._get!(Tag.sRecipeBookSeenRecipe).witClone); break; + case Tag.sRenameItem: return _create!(Tag.sRenameItem)(this._get!(Tag.sRenameItem).witClone); break; + case Tag.sPlayResourcePack: return _create!(Tag.sPlayResourcePack)(this._get!(Tag.sPlayResourcePack).witClone); break; + case Tag.sSeenAdvancement: return _create!(Tag.sSeenAdvancement)(this._get!(Tag.sSeenAdvancement).witClone); break; + case Tag.sSelectTrade: return _create!(Tag.sSelectTrade)(this._get!(Tag.sSelectTrade).witClone); break; + case Tag.sSetBeacon: return _create!(Tag.sSetBeacon)(this._get!(Tag.sSetBeacon).witClone); break; + case Tag.sSetCommandBlock: return _create!(Tag.sSetCommandBlock)(this._get!(Tag.sSetCommandBlock).witClone); break; + case Tag.sSetCommandMinecart: return _create!(Tag.sSetCommandMinecart)(this._get!(Tag.sSetCommandMinecart).witClone); break; + case Tag.sSetCreativeSlot: return _create!(Tag.sSetCreativeSlot)(this._get!(Tag.sSetCreativeSlot).witClone); break; + case Tag.sSetGameRule: return _create!(Tag.sSetGameRule)(this._get!(Tag.sSetGameRule).witClone); break; + case Tag.sSetHeldItem: return _create!(Tag.sSetHeldItem)(this._get!(Tag.sSetHeldItem).witClone); break; + case Tag.sSetJigsawBlock: return _create!(Tag.sSetJigsawBlock)(this._get!(Tag.sSetJigsawBlock).witClone); break; + case Tag.sSetStructureBlock: return _create!(Tag.sSetStructureBlock)(this._get!(Tag.sSetStructureBlock).witClone); break; + case Tag.sSetTestBlock: return _create!(Tag.sSetTestBlock)(this._get!(Tag.sSetTestBlock).witClone); break; + case Tag.sSpectateEntity: return _create!(Tag.sSpectateEntity)(this._get!(Tag.sSpectateEntity).witClone); break; + case Tag.sSwingArm: return _create!(Tag.sSwingArm)(this._get!(Tag.sSwingArm).witClone); break; + case Tag.sTeleportToEntity: return _create!(Tag.sTeleportToEntity)(this._get!(Tag.sTeleportToEntity).witClone); break; + case Tag.sTestInstanceBlockAction: return _create!(Tag.sTestInstanceBlockAction)(this._get!(Tag.sTestInstanceBlockAction).witClone); break; + case Tag.sUpdateSign: return _create!(Tag.sUpdateSign)(this._get!(Tag.sUpdateSign).witClone); break; + case Tag.sUseItem: return _create!(Tag.sUseItem)(this._get!(Tag.sUseItem).witClone); break; + case Tag.sUseItemOn: return _create!(Tag.sUseItemOn)(this._get!(Tag.sUseItemOn).witClone); break; + case Tag.statusSStatusPingRequest: return _create!(Tag.statusSStatusPingRequest)(this._get!(Tag.statusSStatusPingRequest).witClone); break; + case Tag.statusSStatusRequest: return _create!(Tag.statusSStatusRequest); break; + case Tag.unknown: return _create!(Tag.unknown); break; + } + } +} + +/++ + ++/ +struct ClientboundPacket { + mixin WitVariant!( + ConfigCConfigAddResourcePack, // configCConfigAddResourcePack + void, // configCConfigClearDialog + ConfigCCodeOfConduct, // configCCodeOfConduct + ConfigCConfigDisconnect, // configCConfigDisconnect + ConfigCCookieRequest, // configCCookieRequest + ConfigCConfigCustomReportDetails, // configCConfigCustomReportDetails + ConfigCFeatureFlags, // configCFeatureFlags + void, // configCFinishConfig + ConfigCKnownPacks, // configCKnownPacks + ConfigCConfigPing, // configCConfigPing + ConfigCPluginMessage, // configCPluginMessage + ConfigCRegistryData, // configCRegistryData + ConfigCConfigRemoveResourcePack, // configCConfigRemoveResourcePack + void, // configCConfigResetChat + ConfigCConfigServerLinks, // configCConfigServerLinks + ConfigCConfigShowDialog, // configCConfigShowDialog + ConfigCStoreCookie, // configCStoreCookie + ConfigCTransfer, // configCTransfer + ConfigCUpdateTags, // configCUpdateTags + LoginCLoginCookieRequest, // loginCLoginCookieRequest + LoginCLoginDisconnect, // loginCLoginDisconnect + LoginCLoginPluginRequest, // loginCLoginPluginRequest + LoginCSetCompression, // loginCSetCompression + CAcknowledgeBlockChange, // cAcknowledgeBlockChange + CActionBar, // cActionBar + CAddResourcePack, // cAddResourcePack + CAwardStats, // cAwardStats + CSetBlockDestroyStage, // cSetBlockDestroyStage + CBlockEntityData, // cBlockEntityData + CBlockEvent, // cBlockEvent + CBlockUpdate, // cBlockUpdate + CBossEvent, // cBossEvent + void, // cBundleDelimiter + CCenterChunk, // cCenterChunk + CChangeDifficulty, // cChangeDifficulty + CChunkBatchEnd, // cChunkBatchEnd + void, // cChunkBatchStart + CChunksBiomes, // cChunksBiomes + void, // cPlayClearDialog + CClearTitle, // cClearTitle + CCloseContainer, // cCloseContainer + CCombatDeath, // cCombatDeath + void, // cCombatEnter + CCombatEnd, // cCombatEnd + CCommandSuggestions, // cCommandSuggestions + CCommands, // cCommands + CPlayCookieRequest, // cPlayCookieRequest + CCustomChatCompletions, // cCustomChatCompletions + CCustomPayload, // cCustomPayload + CPlayCustomReportDetails, // cPlayCustomReportDetails + CDamageEvent, // cDamageEvent + CDebugBlockValue, // cDebugBlockValue + CDebugChunkValue, // cDebugChunkValue + CDebugEntityValue, // cDebugEntityValue + CDebugEvent, // cDebugEvent + CDebugSample, // cDebugSample + CDeleteChat, // cDeleteChat + CPlayDisconnect, // cPlayDisconnect + CDisguisedChatMessage, // cDisguisedChatMessage + CDisplayObjective, // cDisplayObjective + CEntityAnimation, // cEntityAnimation + CSetEntityMetadata, // cSetEntityMetadata + CEntitySoundEffect, // cEntitySoundEffect + CEntityStatus, // cEntityStatus + CEntityVelocity, // cEntityVelocity + CExplosion, // cExplosion + CGameEvent, // cGameEvent + CGameRuleValues, // cGameRuleValues + CGameTestHighlightPos, // cGameTestHighlightPos + CHeadRot, // cHeadRot + CHurtAnimation, // cHurtAnimation + CInitializeWorldBorder, // cInitializeWorldBorder + CItemCooldown, // cItemCooldown + CKeepAlive, // cKeepAlive + CLevelEvent, // cLevelEvent + CLightUpdate, // cLightUpdate + CLogin, // cLogin + void, // cLowDiskSpaceWarning + CMapItemData, // cMapItemData + CMerchantOffers, // cMerchantOffers + CMoveMinecartAlongTrack, // cMoveMinecartAlongTrack + CMoveVehicle, // cMoveVehicle + CMultiBlockUpdate, // cMultiBlockUpdate + COpenBook, // cOpenBook + COpenMountScreen, // cOpenMountScreen + COpenScreen, // cOpenScreen + COpenSignEditor, // cOpenSignEditor + CParticle, // cParticle + CPlayPing, // cPlayPing + CPingResponse, // cPingResponse + CPlaceGhostRecipe, // cPlaceGhostRecipe + CPlayerAbilities, // cPlayerAbilities + CPlayerChatMessage, // cPlayerChatMessage + CPlayerInfoUpdate, // cPlayerInfoUpdate + CPlayerLookAt, // cPlayerLookAt + CPlayerPosition, // cPlayerPosition + CRemovePlayerInfo, // cRemovePlayerInfo + CPlayerRotation, // cPlayerRotation + CPlayerSpawnPosition, // cPlayerSpawnPosition + CProjectilePower, // cProjectilePower + CRecipeBookAdd, // cRecipeBookAdd + CRecipeBookRemove, // cRecipeBookRemove + CRecipeBookSettings, // cRecipeBookSettings + CRemoveEntities, // cRemoveEntities + CRemoveMobEffect, // cRemoveMobEffect + CRemoveResourcePack, // cRemoveResourcePack + CResetScore, // cResetScore + CRespawn, // cRespawn + CSelectAdvancementsTab, // cSelectAdvancementsTab + CServerData, // cServerData + CPlayServerLinks, // cPlayServerLinks + CSetBorderCenter, // cSetBorderCenter + CSetBorderLerpSize, // cSetBorderLerpSize + CSetBorderSize, // cSetBorderSize + CSetBorderWarningDelay, // cSetBorderWarningDelay + CSetBorderWarningDistance, // cSetBorderWarningDistance + CSetCamera, // cSetCamera + CSetChunkCacheRadius, // cSetChunkCacheRadius + CSetContainerContent, // cSetContainerContent + CSetContainerProperty, // cSetContainerProperty + CSetContainerSlot, // cSetContainerSlot + CSetCursorItem, // cSetCursorItem + CSetEntityLink, // cSetEntityLink + CSetEquipment, // cSetEquipment + CSetExperience, // cSetExperience + CSetHealth, // cSetHealth + CSetPassengers, // cSetPassengers + CSetPlayerInventory, // cSetPlayerInventory + CSetPlayerTeam, // cSetPlayerTeam + CSetSimulationDistance, // cSetSimulationDistance + CUpdateTime, // cUpdateTime + CTitleText, // cTitleText + CTitleAnimation, // cTitleAnimation + CPlayShowDialog, // cPlayShowDialog + CSoundEffect, // cSoundEffect + CSpawnEntity, // cSpawnEntity + CSpawnLivingEntity, // cSpawnLivingEntity + CSpawnPainting, // cSpawnPainting + void, // cStartConfiguration + CStopSound, // cStopSound + CStoreCookie, // cStoreCookie + CSubtitle, // cSubtitle + CTabList, // cTabList + CTagQueryResponse, // cTagQueryResponse + CTakeItemEntity, // cTakeItemEntity + CTeleportEntity, // cTeleportEntity + CTestInstanceBlockStatus, // cTestInstanceBlockStatus + CTickingState, // cTickingState + CTickingStep, // cTickingStep + CTransfer, // cTransfer + CUnloadChunk, // cUnloadChunk + CUpdateAdvancements, // cUpdateAdvancements + CUpdateAttributes, // cUpdateAttributes + CUpdateEntityPos, // cUpdateEntityPos + CUpdateEntityPosRot, // cUpdateEntityPosRot + CUpdateEntityRot, // cUpdateEntityRot + CUpdateMobEffect, // cUpdateMobEffect + CUpdateObjectives, // cUpdateObjectives + CUpdateRecipes, // cUpdateRecipes + CUpdateScore, // cUpdateScore + CUseBed, // cUseBed + CWaypoint, // cWaypoint + CWorldEvent, // cWorldEvent + StatusCPingResponse, // statusCPingResponse + StatusCStatusResponse, // statusCStatusResponse + void, // unknown + ); + +public: + enum Tag : ubyte { + /++ + + +/ + configCConfigAddResourcePack, + + /++ + + +/ + configCConfigClearDialog, + + /++ + + +/ + configCCodeOfConduct, + + /++ + + +/ + configCConfigDisconnect, + + /++ + + +/ + configCCookieRequest, + + /++ + + +/ + configCConfigCustomReportDetails, + + /++ + + +/ + configCFeatureFlags, + + /++ + + +/ + configCFinishConfig, + + /++ + + +/ + configCKnownPacks, + + /++ + + +/ + configCConfigPing, + + /++ + + +/ + configCPluginMessage, + + /++ + + +/ + configCRegistryData, + + /++ + + +/ + configCConfigRemoveResourcePack, + + /++ + + +/ + configCConfigResetChat, + + /++ + + +/ + configCConfigServerLinks, + + /++ + + +/ + configCConfigShowDialog, + + /++ + + +/ + configCStoreCookie, + + /++ + + +/ + configCTransfer, + + /++ + + +/ + configCUpdateTags, + + /++ + + +/ + loginCLoginCookieRequest, + + /++ + + +/ + loginCLoginDisconnect, + + /++ + + +/ + loginCLoginPluginRequest, + + /++ + + +/ + loginCSetCompression, + + /++ + + +/ + cAcknowledgeBlockChange, + + /++ + + +/ + cActionBar, + + /++ + + +/ + cAddResourcePack, + + /++ + + +/ + cAwardStats, + + /++ + + +/ + cSetBlockDestroyStage, + + /++ + + +/ + cBlockEntityData, + + /++ + + +/ + cBlockEvent, + + /++ + + +/ + cBlockUpdate, + + /++ + + +/ + cBossEvent, + + /++ + + +/ + cBundleDelimiter, + + /++ + + +/ + cCenterChunk, + + /++ + + +/ + cChangeDifficulty, + + /++ + + +/ + cChunkBatchEnd, + + /++ + + +/ + cChunkBatchStart, + + /++ + + +/ + cChunksBiomes, + + /++ + + +/ + cPlayClearDialog, + + /++ + + +/ + cClearTitle, + + /++ + + +/ + cCloseContainer, + + /++ + + +/ + cCombatDeath, + + /++ + + +/ + cCombatEnter, + + /++ + + +/ + cCombatEnd, + + /++ + + +/ + cCommandSuggestions, + + /++ + + +/ + cCommands, + + /++ + + +/ + cPlayCookieRequest, + + /++ + + +/ + cCustomChatCompletions, + + /++ + + +/ + cCustomPayload, + + /++ + + +/ + cPlayCustomReportDetails, + + /++ + + +/ + cDamageEvent, + + /++ + + +/ + cDebugBlockValue, + + /++ + + +/ + cDebugChunkValue, + + /++ + + +/ + cDebugEntityValue, + + /++ + + +/ + cDebugEvent, + + /++ + + +/ + cDebugSample, + + /++ + + +/ + cDeleteChat, + + /++ + + +/ + cPlayDisconnect, + + /++ + + +/ + cDisguisedChatMessage, + + /++ + + +/ + cDisplayObjective, + + /++ + + +/ + cEntityAnimation, + + /++ + + +/ + cSetEntityMetadata, + + /++ + + +/ + cEntitySoundEffect, + + /++ + + +/ + cEntityStatus, + + /++ + + +/ + cEntityVelocity, + + /++ + + +/ + cExplosion, + + /++ + + +/ + cGameEvent, + + /++ + + +/ + cGameRuleValues, + + /++ + + +/ + cGameTestHighlightPos, + + /++ + + +/ + cHeadRot, + + /++ + + +/ + cHurtAnimation, + + /++ + + +/ + cInitializeWorldBorder, + + /++ + + +/ + cItemCooldown, + + /++ + + +/ + cKeepAlive, + + /++ + + +/ + cLevelEvent, + + /++ + + +/ + cLightUpdate, + + /++ + + +/ + cLogin, + + /++ + + +/ + cLowDiskSpaceWarning, + + /++ + + +/ + cMapItemData, + + /++ + + +/ + cMerchantOffers, + + /++ + + +/ + cMoveMinecartAlongTrack, + + /++ + + +/ + cMoveVehicle, + + /++ + + +/ + cMultiBlockUpdate, + + /++ + + +/ + cOpenBook, + + /++ + + +/ + cOpenMountScreen, + + /++ + + +/ + cOpenScreen, + + /++ + + +/ + cOpenSignEditor, + + /++ + + +/ + cParticle, + + /++ + + +/ + cPlayPing, + + /++ + + +/ + cPingResponse, + + /++ + + +/ + cPlaceGhostRecipe, + + /++ + + +/ + cPlayerAbilities, + + /++ + + +/ + cPlayerChatMessage, + + /++ + + +/ + cPlayerInfoUpdate, + + /++ + + +/ + cPlayerLookAt, + + /++ + + +/ + cPlayerPosition, + + /++ + + +/ + cRemovePlayerInfo, + + /++ + + +/ + cPlayerRotation, + + /++ + + +/ + cPlayerSpawnPosition, + + /++ + + +/ + cProjectilePower, + + /++ + + +/ + cRecipeBookAdd, + + /++ + + +/ + cRecipeBookRemove, + + /++ + + +/ + cRecipeBookSettings, + + /++ + + +/ + cRemoveEntities, + + /++ + + +/ + cRemoveMobEffect, + + /++ + + +/ + cRemoveResourcePack, + + /++ + + +/ + cResetScore, + + /++ + + +/ + cRespawn, + + /++ + + +/ + cSelectAdvancementsTab, + + /++ + + +/ + cServerData, + + /++ + + +/ + cPlayServerLinks, + + /++ + + +/ + cSetBorderCenter, + + /++ + + +/ + cSetBorderLerpSize, + + /++ + + +/ + cSetBorderSize, + + /++ + + +/ + cSetBorderWarningDelay, + + /++ + + +/ + cSetBorderWarningDistance, + + /++ + + +/ + cSetCamera, + + /++ + + +/ + cSetChunkCacheRadius, + + /++ + + +/ + cSetContainerContent, + + /++ + + +/ + cSetContainerProperty, + + /++ + + +/ + cSetContainerSlot, + + /++ + + +/ + cSetCursorItem, + + /++ + + +/ + cSetEntityLink, + + /++ + + +/ + cSetEquipment, + + /++ + + +/ + cSetExperience, + + /++ + + +/ + cSetHealth, + + /++ + + +/ + cSetPassengers, + + /++ + + +/ + cSetPlayerInventory, + + /++ + + +/ + cSetPlayerTeam, + + /++ + + +/ + cSetSimulationDistance, + + /++ + + +/ + cUpdateTime, + + /++ + + +/ + cTitleText, + + /++ + + +/ + cTitleAnimation, + + /++ + + +/ + cPlayShowDialog, + + /++ + + +/ + cSoundEffect, + + /++ + + +/ + cSpawnEntity, + + /++ + + +/ + cSpawnLivingEntity, + + /++ + + +/ + cSpawnPainting, + + /++ + + +/ + cStartConfiguration, + + /++ + + +/ + cStopSound, + + /++ + + +/ + cStoreCookie, + + /++ + + +/ + cSubtitle, + + /++ + + +/ + cTabList, + + /++ + + +/ + cTagQueryResponse, + + /++ + + +/ + cTakeItemEntity, + + /++ + + +/ + cTeleportEntity, + + /++ + + +/ + cTestInstanceBlockStatus, + + /++ + + +/ + cTickingState, + + /++ + + +/ + cTickingStep, + + /++ + + +/ + cTransfer, + + /++ + + +/ + cUnloadChunk, + + /++ + + +/ + cUpdateAdvancements, + + /++ + + +/ + cUpdateAttributes, + + /++ + + +/ + cUpdateEntityPos, + + /++ + + +/ + cUpdateEntityPosRot, + + /++ + + +/ + cUpdateEntityRot, + + /++ + + +/ + cUpdateMobEffect, + + /++ + + +/ + cUpdateObjectives, + + /++ + + +/ + cUpdateRecipes, + + /++ + + +/ + cUpdateScore, + + /++ + + +/ + cUseBed, + + /++ + + +/ + cWaypoint, + + /++ + + +/ + cWorldEvent, + + /++ + + +/ + statusCPingResponse, + + /++ + + +/ + statusCStatusResponse, + + /++ + + +/ + unknown, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias configCConfigAddResourcePack = _create!(Tag.configCConfigAddResourcePack); + /// ditto + pragma(inline, true) bool isConfigCConfigAddResourcePack() const => _tag == Tag.configCConfigAddResourcePack; + ///ditto + alias getConfigCConfigAddResourcePack = _get!(Tag.configCConfigAddResourcePack); + + /++ + + +/ + alias configCConfigClearDialog = _create!(Tag.configCConfigClearDialog); + /// ditto + pragma(inline, true) bool isConfigCConfigClearDialog() const => _tag == Tag.configCConfigClearDialog; + + /++ + + +/ + alias configCCodeOfConduct = _create!(Tag.configCCodeOfConduct); + /// ditto + pragma(inline, true) bool isConfigCCodeOfConduct() const => _tag == Tag.configCCodeOfConduct; + ///ditto + alias getConfigCCodeOfConduct = _get!(Tag.configCCodeOfConduct); + + /++ + + +/ + alias configCConfigDisconnect = _create!(Tag.configCConfigDisconnect); + /// ditto + pragma(inline, true) bool isConfigCConfigDisconnect() const => _tag == Tag.configCConfigDisconnect; + ///ditto + alias getConfigCConfigDisconnect = _get!(Tag.configCConfigDisconnect); + + /++ + + +/ + alias configCCookieRequest = _create!(Tag.configCCookieRequest); + /// ditto + pragma(inline, true) bool isConfigCCookieRequest() const => _tag == Tag.configCCookieRequest; + ///ditto + alias getConfigCCookieRequest = _get!(Tag.configCCookieRequest); + + /++ + + +/ + alias configCConfigCustomReportDetails = _create!(Tag.configCConfigCustomReportDetails); + /// ditto + pragma(inline, true) bool isConfigCConfigCustomReportDetails() const => _tag == Tag.configCConfigCustomReportDetails; + ///ditto + alias getConfigCConfigCustomReportDetails = _get!(Tag.configCConfigCustomReportDetails); + + /++ + + +/ + alias configCFeatureFlags = _create!(Tag.configCFeatureFlags); + /// ditto + pragma(inline, true) bool isConfigCFeatureFlags() const => _tag == Tag.configCFeatureFlags; + ///ditto + alias getConfigCFeatureFlags = _get!(Tag.configCFeatureFlags); + + /++ + + +/ + alias configCFinishConfig = _create!(Tag.configCFinishConfig); + /// ditto + pragma(inline, true) bool isConfigCFinishConfig() const => _tag == Tag.configCFinishConfig; + + /++ + + +/ + alias configCKnownPacks = _create!(Tag.configCKnownPacks); + /// ditto + pragma(inline, true) bool isConfigCKnownPacks() const => _tag == Tag.configCKnownPacks; + ///ditto + alias getConfigCKnownPacks = _get!(Tag.configCKnownPacks); + + /++ + + +/ + alias configCConfigPing = _create!(Tag.configCConfigPing); + /// ditto + pragma(inline, true) bool isConfigCConfigPing() const => _tag == Tag.configCConfigPing; + ///ditto + alias getConfigCConfigPing = _get!(Tag.configCConfigPing); + + /++ + + +/ + alias configCPluginMessage = _create!(Tag.configCPluginMessage); + /// ditto + pragma(inline, true) bool isConfigCPluginMessage() const => _tag == Tag.configCPluginMessage; + ///ditto + alias getConfigCPluginMessage = _get!(Tag.configCPluginMessage); + + /++ + + +/ + alias configCRegistryData = _create!(Tag.configCRegistryData); + /// ditto + pragma(inline, true) bool isConfigCRegistryData() const => _tag == Tag.configCRegistryData; + ///ditto + alias getConfigCRegistryData = _get!(Tag.configCRegistryData); + + /++ + + +/ + alias configCConfigRemoveResourcePack = _create!(Tag.configCConfigRemoveResourcePack); + /// ditto + pragma(inline, true) bool isConfigCConfigRemoveResourcePack() const => _tag == Tag.configCConfigRemoveResourcePack; + ///ditto + alias getConfigCConfigRemoveResourcePack = _get!(Tag.configCConfigRemoveResourcePack); + + /++ + + +/ + alias configCConfigResetChat = _create!(Tag.configCConfigResetChat); + /// ditto + pragma(inline, true) bool isConfigCConfigResetChat() const => _tag == Tag.configCConfigResetChat; + + /++ + + +/ + alias configCConfigServerLinks = _create!(Tag.configCConfigServerLinks); + /// ditto + pragma(inline, true) bool isConfigCConfigServerLinks() const => _tag == Tag.configCConfigServerLinks; + ///ditto + alias getConfigCConfigServerLinks = _get!(Tag.configCConfigServerLinks); + + /++ + + +/ + alias configCConfigShowDialog = _create!(Tag.configCConfigShowDialog); + /// ditto + pragma(inline, true) bool isConfigCConfigShowDialog() const => _tag == Tag.configCConfigShowDialog; + ///ditto + alias getConfigCConfigShowDialog = _get!(Tag.configCConfigShowDialog); + + /++ + + +/ + alias configCStoreCookie = _create!(Tag.configCStoreCookie); + /// ditto + pragma(inline, true) bool isConfigCStoreCookie() const => _tag == Tag.configCStoreCookie; + ///ditto + alias getConfigCStoreCookie = _get!(Tag.configCStoreCookie); + + /++ + + +/ + alias configCTransfer = _create!(Tag.configCTransfer); + /// ditto + pragma(inline, true) bool isConfigCTransfer() const => _tag == Tag.configCTransfer; + ///ditto + alias getConfigCTransfer = _get!(Tag.configCTransfer); + + /++ + + +/ + alias configCUpdateTags = _create!(Tag.configCUpdateTags); + /// ditto + pragma(inline, true) bool isConfigCUpdateTags() const => _tag == Tag.configCUpdateTags; + ///ditto + alias getConfigCUpdateTags = _get!(Tag.configCUpdateTags); + + /++ + + +/ + alias loginCLoginCookieRequest = _create!(Tag.loginCLoginCookieRequest); + /// ditto + pragma(inline, true) bool isLoginCLoginCookieRequest() const => _tag == Tag.loginCLoginCookieRequest; + ///ditto + alias getLoginCLoginCookieRequest = _get!(Tag.loginCLoginCookieRequest); + + /++ + + +/ + alias loginCLoginDisconnect = _create!(Tag.loginCLoginDisconnect); + /// ditto + pragma(inline, true) bool isLoginCLoginDisconnect() const => _tag == Tag.loginCLoginDisconnect; + ///ditto + alias getLoginCLoginDisconnect = _get!(Tag.loginCLoginDisconnect); + + /++ + + +/ + alias loginCLoginPluginRequest = _create!(Tag.loginCLoginPluginRequest); + /// ditto + pragma(inline, true) bool isLoginCLoginPluginRequest() const => _tag == Tag.loginCLoginPluginRequest; + ///ditto + alias getLoginCLoginPluginRequest = _get!(Tag.loginCLoginPluginRequest); + + /++ + + +/ + alias loginCSetCompression = _create!(Tag.loginCSetCompression); + /// ditto + pragma(inline, true) bool isLoginCSetCompression() const => _tag == Tag.loginCSetCompression; + ///ditto + alias getLoginCSetCompression = _get!(Tag.loginCSetCompression); + + /++ + + +/ + alias cAcknowledgeBlockChange = _create!(Tag.cAcknowledgeBlockChange); + /// ditto + pragma(inline, true) bool isCAcknowledgeBlockChange() const => _tag == Tag.cAcknowledgeBlockChange; + ///ditto + alias getCAcknowledgeBlockChange = _get!(Tag.cAcknowledgeBlockChange); + + /++ + + +/ + alias cActionBar = _create!(Tag.cActionBar); + /// ditto + pragma(inline, true) bool isCActionBar() const => _tag == Tag.cActionBar; + ///ditto + alias getCActionBar = _get!(Tag.cActionBar); + + /++ + + +/ + alias cAddResourcePack = _create!(Tag.cAddResourcePack); + /// ditto + pragma(inline, true) bool isCAddResourcePack() const => _tag == Tag.cAddResourcePack; + ///ditto + alias getCAddResourcePack = _get!(Tag.cAddResourcePack); + + /++ + + +/ + alias cAwardStats = _create!(Tag.cAwardStats); + /// ditto + pragma(inline, true) bool isCAwardStats() const => _tag == Tag.cAwardStats; + ///ditto + alias getCAwardStats = _get!(Tag.cAwardStats); + + /++ + + +/ + alias cSetBlockDestroyStage = _create!(Tag.cSetBlockDestroyStage); + /// ditto + pragma(inline, true) bool isCSetBlockDestroyStage() const => _tag == Tag.cSetBlockDestroyStage; + ///ditto + alias getCSetBlockDestroyStage = _get!(Tag.cSetBlockDestroyStage); + + /++ + + +/ + alias cBlockEntityData = _create!(Tag.cBlockEntityData); + /// ditto + pragma(inline, true) bool isCBlockEntityData() const => _tag == Tag.cBlockEntityData; + ///ditto + alias getCBlockEntityData = _get!(Tag.cBlockEntityData); + + /++ + + +/ + alias cBlockEvent = _create!(Tag.cBlockEvent); + /// ditto + pragma(inline, true) bool isCBlockEvent() const => _tag == Tag.cBlockEvent; + ///ditto + alias getCBlockEvent = _get!(Tag.cBlockEvent); + + /++ + + +/ + alias cBlockUpdate = _create!(Tag.cBlockUpdate); + /// ditto + pragma(inline, true) bool isCBlockUpdate() const => _tag == Tag.cBlockUpdate; + ///ditto + alias getCBlockUpdate = _get!(Tag.cBlockUpdate); + + /++ + + +/ + alias cBossEvent = _create!(Tag.cBossEvent); + /// ditto + pragma(inline, true) bool isCBossEvent() const => _tag == Tag.cBossEvent; + ///ditto + alias getCBossEvent = _get!(Tag.cBossEvent); + + /++ + + +/ + alias cBundleDelimiter = _create!(Tag.cBundleDelimiter); + /// ditto + pragma(inline, true) bool isCBundleDelimiter() const => _tag == Tag.cBundleDelimiter; + + /++ + + +/ + alias cCenterChunk = _create!(Tag.cCenterChunk); + /// ditto + pragma(inline, true) bool isCCenterChunk() const => _tag == Tag.cCenterChunk; + ///ditto + alias getCCenterChunk = _get!(Tag.cCenterChunk); + + /++ + + +/ + alias cChangeDifficulty = _create!(Tag.cChangeDifficulty); + /// ditto + pragma(inline, true) bool isCChangeDifficulty() const => _tag == Tag.cChangeDifficulty; + ///ditto + alias getCChangeDifficulty = _get!(Tag.cChangeDifficulty); + + /++ + + +/ + alias cChunkBatchEnd = _create!(Tag.cChunkBatchEnd); + /// ditto + pragma(inline, true) bool isCChunkBatchEnd() const => _tag == Tag.cChunkBatchEnd; + ///ditto + alias getCChunkBatchEnd = _get!(Tag.cChunkBatchEnd); + + /++ + + +/ + alias cChunkBatchStart = _create!(Tag.cChunkBatchStart); + /// ditto + pragma(inline, true) bool isCChunkBatchStart() const => _tag == Tag.cChunkBatchStart; + + /++ + + +/ + alias cChunksBiomes = _create!(Tag.cChunksBiomes); + /// ditto + pragma(inline, true) bool isCChunksBiomes() const => _tag == Tag.cChunksBiomes; + ///ditto + alias getCChunksBiomes = _get!(Tag.cChunksBiomes); + + /++ + + +/ + alias cPlayClearDialog = _create!(Tag.cPlayClearDialog); + /// ditto + pragma(inline, true) bool isCPlayClearDialog() const => _tag == Tag.cPlayClearDialog; + + /++ + + +/ + alias cClearTitle = _create!(Tag.cClearTitle); + /// ditto + pragma(inline, true) bool isCClearTitle() const => _tag == Tag.cClearTitle; + ///ditto + alias getCClearTitle = _get!(Tag.cClearTitle); + + /++ + + +/ + alias cCloseContainer = _create!(Tag.cCloseContainer); + /// ditto + pragma(inline, true) bool isCCloseContainer() const => _tag == Tag.cCloseContainer; + ///ditto + alias getCCloseContainer = _get!(Tag.cCloseContainer); + + /++ + + +/ + alias cCombatDeath = _create!(Tag.cCombatDeath); + /// ditto + pragma(inline, true) bool isCCombatDeath() const => _tag == Tag.cCombatDeath; + ///ditto + alias getCCombatDeath = _get!(Tag.cCombatDeath); + + /++ + + +/ + alias cCombatEnter = _create!(Tag.cCombatEnter); + /// ditto + pragma(inline, true) bool isCCombatEnter() const => _tag == Tag.cCombatEnter; + + /++ + + +/ + alias cCombatEnd = _create!(Tag.cCombatEnd); + /// ditto + pragma(inline, true) bool isCCombatEnd() const => _tag == Tag.cCombatEnd; + ///ditto + alias getCCombatEnd = _get!(Tag.cCombatEnd); + + /++ + + +/ + alias cCommandSuggestions = _create!(Tag.cCommandSuggestions); + /// ditto + pragma(inline, true) bool isCCommandSuggestions() const => _tag == Tag.cCommandSuggestions; + ///ditto + alias getCCommandSuggestions = _get!(Tag.cCommandSuggestions); + + /++ + + +/ + alias cCommands = _create!(Tag.cCommands); + /// ditto + pragma(inline, true) bool isCCommands() const => _tag == Tag.cCommands; + ///ditto + alias getCCommands = _get!(Tag.cCommands); + + /++ + + +/ + alias cPlayCookieRequest = _create!(Tag.cPlayCookieRequest); + /// ditto + pragma(inline, true) bool isCPlayCookieRequest() const => _tag == Tag.cPlayCookieRequest; + ///ditto + alias getCPlayCookieRequest = _get!(Tag.cPlayCookieRequest); + + /++ + + +/ + alias cCustomChatCompletions = _create!(Tag.cCustomChatCompletions); + /// ditto + pragma(inline, true) bool isCCustomChatCompletions() const => _tag == Tag.cCustomChatCompletions; + ///ditto + alias getCCustomChatCompletions = _get!(Tag.cCustomChatCompletions); + + /++ + + +/ + alias cCustomPayload = _create!(Tag.cCustomPayload); + /// ditto + pragma(inline, true) bool isCCustomPayload() const => _tag == Tag.cCustomPayload; + ///ditto + alias getCCustomPayload = _get!(Tag.cCustomPayload); + + /++ + + +/ + alias cPlayCustomReportDetails = _create!(Tag.cPlayCustomReportDetails); + /// ditto + pragma(inline, true) bool isCPlayCustomReportDetails() const => _tag == Tag.cPlayCustomReportDetails; + ///ditto + alias getCPlayCustomReportDetails = _get!(Tag.cPlayCustomReportDetails); + + /++ + + +/ + alias cDamageEvent = _create!(Tag.cDamageEvent); + /// ditto + pragma(inline, true) bool isCDamageEvent() const => _tag == Tag.cDamageEvent; + ///ditto + alias getCDamageEvent = _get!(Tag.cDamageEvent); + + /++ + + +/ + alias cDebugBlockValue = _create!(Tag.cDebugBlockValue); + /// ditto + pragma(inline, true) bool isCDebugBlockValue() const => _tag == Tag.cDebugBlockValue; + ///ditto + alias getCDebugBlockValue = _get!(Tag.cDebugBlockValue); + + /++ + + +/ + alias cDebugChunkValue = _create!(Tag.cDebugChunkValue); + /// ditto + pragma(inline, true) bool isCDebugChunkValue() const => _tag == Tag.cDebugChunkValue; + ///ditto + alias getCDebugChunkValue = _get!(Tag.cDebugChunkValue); + + /++ + + +/ + alias cDebugEntityValue = _create!(Tag.cDebugEntityValue); + /// ditto + pragma(inline, true) bool isCDebugEntityValue() const => _tag == Tag.cDebugEntityValue; + ///ditto + alias getCDebugEntityValue = _get!(Tag.cDebugEntityValue); + + /++ + + +/ + alias cDebugEvent = _create!(Tag.cDebugEvent); + /// ditto + pragma(inline, true) bool isCDebugEvent() const => _tag == Tag.cDebugEvent; + ///ditto + alias getCDebugEvent = _get!(Tag.cDebugEvent); + + /++ + + +/ + alias cDebugSample = _create!(Tag.cDebugSample); + /// ditto + pragma(inline, true) bool isCDebugSample() const => _tag == Tag.cDebugSample; + ///ditto + alias getCDebugSample = _get!(Tag.cDebugSample); + + /++ + + +/ + alias cDeleteChat = _create!(Tag.cDeleteChat); + /// ditto + pragma(inline, true) bool isCDeleteChat() const => _tag == Tag.cDeleteChat; + ///ditto + alias getCDeleteChat = _get!(Tag.cDeleteChat); + + /++ + + +/ + alias cPlayDisconnect = _create!(Tag.cPlayDisconnect); + /// ditto + pragma(inline, true) bool isCPlayDisconnect() const => _tag == Tag.cPlayDisconnect; + ///ditto + alias getCPlayDisconnect = _get!(Tag.cPlayDisconnect); + + /++ + + +/ + alias cDisguisedChatMessage = _create!(Tag.cDisguisedChatMessage); + /// ditto + pragma(inline, true) bool isCDisguisedChatMessage() const => _tag == Tag.cDisguisedChatMessage; + ///ditto + alias getCDisguisedChatMessage = _get!(Tag.cDisguisedChatMessage); + + /++ + + +/ + alias cDisplayObjective = _create!(Tag.cDisplayObjective); + /// ditto + pragma(inline, true) bool isCDisplayObjective() const => _tag == Tag.cDisplayObjective; + ///ditto + alias getCDisplayObjective = _get!(Tag.cDisplayObjective); + + /++ + + +/ + alias cEntityAnimation = _create!(Tag.cEntityAnimation); + /// ditto + pragma(inline, true) bool isCEntityAnimation() const => _tag == Tag.cEntityAnimation; + ///ditto + alias getCEntityAnimation = _get!(Tag.cEntityAnimation); + + /++ + + +/ + alias cSetEntityMetadata = _create!(Tag.cSetEntityMetadata); + /// ditto + pragma(inline, true) bool isCSetEntityMetadata() const => _tag == Tag.cSetEntityMetadata; + ///ditto + alias getCSetEntityMetadata = _get!(Tag.cSetEntityMetadata); + + /++ + + +/ + alias cEntitySoundEffect = _create!(Tag.cEntitySoundEffect); + /// ditto + pragma(inline, true) bool isCEntitySoundEffect() const => _tag == Tag.cEntitySoundEffect; + ///ditto + alias getCEntitySoundEffect = _get!(Tag.cEntitySoundEffect); + + /++ + + +/ + alias cEntityStatus = _create!(Tag.cEntityStatus); + /// ditto + pragma(inline, true) bool isCEntityStatus() const => _tag == Tag.cEntityStatus; + ///ditto + alias getCEntityStatus = _get!(Tag.cEntityStatus); + + /++ + + +/ + alias cEntityVelocity = _create!(Tag.cEntityVelocity); + /// ditto + pragma(inline, true) bool isCEntityVelocity() const => _tag == Tag.cEntityVelocity; + ///ditto + alias getCEntityVelocity = _get!(Tag.cEntityVelocity); + + /++ + + +/ + alias cExplosion = _create!(Tag.cExplosion); + /// ditto + pragma(inline, true) bool isCExplosion() const => _tag == Tag.cExplosion; + ///ditto + alias getCExplosion = _get!(Tag.cExplosion); + + /++ + + +/ + alias cGameEvent = _create!(Tag.cGameEvent); + /// ditto + pragma(inline, true) bool isCGameEvent() const => _tag == Tag.cGameEvent; + ///ditto + alias getCGameEvent = _get!(Tag.cGameEvent); + + /++ + + +/ + alias cGameRuleValues = _create!(Tag.cGameRuleValues); + /// ditto + pragma(inline, true) bool isCGameRuleValues() const => _tag == Tag.cGameRuleValues; + ///ditto + alias getCGameRuleValues = _get!(Tag.cGameRuleValues); + + /++ + + +/ + alias cGameTestHighlightPos = _create!(Tag.cGameTestHighlightPos); + /// ditto + pragma(inline, true) bool isCGameTestHighlightPos() const => _tag == Tag.cGameTestHighlightPos; + ///ditto + alias getCGameTestHighlightPos = _get!(Tag.cGameTestHighlightPos); + + /++ + + +/ + alias cHeadRot = _create!(Tag.cHeadRot); + /// ditto + pragma(inline, true) bool isCHeadRot() const => _tag == Tag.cHeadRot; + ///ditto + alias getCHeadRot = _get!(Tag.cHeadRot); + + /++ + + +/ + alias cHurtAnimation = _create!(Tag.cHurtAnimation); + /// ditto + pragma(inline, true) bool isCHurtAnimation() const => _tag == Tag.cHurtAnimation; + ///ditto + alias getCHurtAnimation = _get!(Tag.cHurtAnimation); + + /++ + + +/ + alias cInitializeWorldBorder = _create!(Tag.cInitializeWorldBorder); + /// ditto + pragma(inline, true) bool isCInitializeWorldBorder() const => _tag == Tag.cInitializeWorldBorder; + ///ditto + alias getCInitializeWorldBorder = _get!(Tag.cInitializeWorldBorder); + + /++ + + +/ + alias cItemCooldown = _create!(Tag.cItemCooldown); + /// ditto + pragma(inline, true) bool isCItemCooldown() const => _tag == Tag.cItemCooldown; + ///ditto + alias getCItemCooldown = _get!(Tag.cItemCooldown); + + /++ + + +/ + alias cKeepAlive = _create!(Tag.cKeepAlive); + /// ditto + pragma(inline, true) bool isCKeepAlive() const => _tag == Tag.cKeepAlive; + ///ditto + alias getCKeepAlive = _get!(Tag.cKeepAlive); + + /++ + + +/ + alias cLevelEvent = _create!(Tag.cLevelEvent); + /// ditto + pragma(inline, true) bool isCLevelEvent() const => _tag == Tag.cLevelEvent; + ///ditto + alias getCLevelEvent = _get!(Tag.cLevelEvent); + + /++ + + +/ + alias cLightUpdate = _create!(Tag.cLightUpdate); + /// ditto + pragma(inline, true) bool isCLightUpdate() const => _tag == Tag.cLightUpdate; + ///ditto + alias getCLightUpdate = _get!(Tag.cLightUpdate); + + /++ + + +/ + alias cLogin = _create!(Tag.cLogin); + /// ditto + pragma(inline, true) bool isCLogin() const => _tag == Tag.cLogin; + ///ditto + alias getCLogin = _get!(Tag.cLogin); + + /++ + + +/ + alias cLowDiskSpaceWarning = _create!(Tag.cLowDiskSpaceWarning); + /// ditto + pragma(inline, true) bool isCLowDiskSpaceWarning() const => _tag == Tag.cLowDiskSpaceWarning; + + /++ + + +/ + alias cMapItemData = _create!(Tag.cMapItemData); + /// ditto + pragma(inline, true) bool isCMapItemData() const => _tag == Tag.cMapItemData; + ///ditto + alias getCMapItemData = _get!(Tag.cMapItemData); + + /++ + + +/ + alias cMerchantOffers = _create!(Tag.cMerchantOffers); + /// ditto + pragma(inline, true) bool isCMerchantOffers() const => _tag == Tag.cMerchantOffers; + ///ditto + alias getCMerchantOffers = _get!(Tag.cMerchantOffers); + + /++ + + +/ + alias cMoveMinecartAlongTrack = _create!(Tag.cMoveMinecartAlongTrack); + /// ditto + pragma(inline, true) bool isCMoveMinecartAlongTrack() const => _tag == Tag.cMoveMinecartAlongTrack; + ///ditto + alias getCMoveMinecartAlongTrack = _get!(Tag.cMoveMinecartAlongTrack); + + /++ + + +/ + alias cMoveVehicle = _create!(Tag.cMoveVehicle); + /// ditto + pragma(inline, true) bool isCMoveVehicle() const => _tag == Tag.cMoveVehicle; + ///ditto + alias getCMoveVehicle = _get!(Tag.cMoveVehicle); + + /++ + + +/ + alias cMultiBlockUpdate = _create!(Tag.cMultiBlockUpdate); + /// ditto + pragma(inline, true) bool isCMultiBlockUpdate() const => _tag == Tag.cMultiBlockUpdate; + ///ditto + alias getCMultiBlockUpdate = _get!(Tag.cMultiBlockUpdate); + + /++ + + +/ + alias cOpenBook = _create!(Tag.cOpenBook); + /// ditto + pragma(inline, true) bool isCOpenBook() const => _tag == Tag.cOpenBook; + ///ditto + alias getCOpenBook = _get!(Tag.cOpenBook); + + /++ + + +/ + alias cOpenMountScreen = _create!(Tag.cOpenMountScreen); + /// ditto + pragma(inline, true) bool isCOpenMountScreen() const => _tag == Tag.cOpenMountScreen; + ///ditto + alias getCOpenMountScreen = _get!(Tag.cOpenMountScreen); + + /++ + + +/ + alias cOpenScreen = _create!(Tag.cOpenScreen); + /// ditto + pragma(inline, true) bool isCOpenScreen() const => _tag == Tag.cOpenScreen; + ///ditto + alias getCOpenScreen = _get!(Tag.cOpenScreen); + + /++ + + +/ + alias cOpenSignEditor = _create!(Tag.cOpenSignEditor); + /// ditto + pragma(inline, true) bool isCOpenSignEditor() const => _tag == Tag.cOpenSignEditor; + ///ditto + alias getCOpenSignEditor = _get!(Tag.cOpenSignEditor); + + /++ + + +/ + alias cParticle = _create!(Tag.cParticle); + /// ditto + pragma(inline, true) bool isCParticle() const => _tag == Tag.cParticle; + ///ditto + alias getCParticle = _get!(Tag.cParticle); + + /++ + + +/ + alias cPlayPing = _create!(Tag.cPlayPing); + /// ditto + pragma(inline, true) bool isCPlayPing() const => _tag == Tag.cPlayPing; + ///ditto + alias getCPlayPing = _get!(Tag.cPlayPing); + + /++ + + +/ + alias cPingResponse = _create!(Tag.cPingResponse); + /// ditto + pragma(inline, true) bool isCPingResponse() const => _tag == Tag.cPingResponse; + ///ditto + alias getCPingResponse = _get!(Tag.cPingResponse); + + /++ + + +/ + alias cPlaceGhostRecipe = _create!(Tag.cPlaceGhostRecipe); + /// ditto + pragma(inline, true) bool isCPlaceGhostRecipe() const => _tag == Tag.cPlaceGhostRecipe; + ///ditto + alias getCPlaceGhostRecipe = _get!(Tag.cPlaceGhostRecipe); + + /++ + + +/ + alias cPlayerAbilities = _create!(Tag.cPlayerAbilities); + /// ditto + pragma(inline, true) bool isCPlayerAbilities() const => _tag == Tag.cPlayerAbilities; + ///ditto + alias getCPlayerAbilities = _get!(Tag.cPlayerAbilities); + + /++ + + +/ + alias cPlayerChatMessage = _create!(Tag.cPlayerChatMessage); + /// ditto + pragma(inline, true) bool isCPlayerChatMessage() const => _tag == Tag.cPlayerChatMessage; + ///ditto + alias getCPlayerChatMessage = _get!(Tag.cPlayerChatMessage); + + /++ + + +/ + alias cPlayerInfoUpdate = _create!(Tag.cPlayerInfoUpdate); + /// ditto + pragma(inline, true) bool isCPlayerInfoUpdate() const => _tag == Tag.cPlayerInfoUpdate; + ///ditto + alias getCPlayerInfoUpdate = _get!(Tag.cPlayerInfoUpdate); + + /++ + + +/ + alias cPlayerLookAt = _create!(Tag.cPlayerLookAt); + /// ditto + pragma(inline, true) bool isCPlayerLookAt() const => _tag == Tag.cPlayerLookAt; + ///ditto + alias getCPlayerLookAt = _get!(Tag.cPlayerLookAt); + + /++ + + +/ + alias cPlayerPosition = _create!(Tag.cPlayerPosition); + /// ditto + pragma(inline, true) bool isCPlayerPosition() const => _tag == Tag.cPlayerPosition; + ///ditto + alias getCPlayerPosition = _get!(Tag.cPlayerPosition); + + /++ + + +/ + alias cRemovePlayerInfo = _create!(Tag.cRemovePlayerInfo); + /// ditto + pragma(inline, true) bool isCRemovePlayerInfo() const => _tag == Tag.cRemovePlayerInfo; + ///ditto + alias getCRemovePlayerInfo = _get!(Tag.cRemovePlayerInfo); + + /++ + + +/ + alias cPlayerRotation = _create!(Tag.cPlayerRotation); + /// ditto + pragma(inline, true) bool isCPlayerRotation() const => _tag == Tag.cPlayerRotation; + ///ditto + alias getCPlayerRotation = _get!(Tag.cPlayerRotation); + + /++ + + +/ + alias cPlayerSpawnPosition = _create!(Tag.cPlayerSpawnPosition); + /// ditto + pragma(inline, true) bool isCPlayerSpawnPosition() const => _tag == Tag.cPlayerSpawnPosition; + ///ditto + alias getCPlayerSpawnPosition = _get!(Tag.cPlayerSpawnPosition); + + /++ + + +/ + alias cProjectilePower = _create!(Tag.cProjectilePower); + /// ditto + pragma(inline, true) bool isCProjectilePower() const => _tag == Tag.cProjectilePower; + ///ditto + alias getCProjectilePower = _get!(Tag.cProjectilePower); + + /++ + + +/ + alias cRecipeBookAdd = _create!(Tag.cRecipeBookAdd); + /// ditto + pragma(inline, true) bool isCRecipeBookAdd() const => _tag == Tag.cRecipeBookAdd; + ///ditto + alias getCRecipeBookAdd = _get!(Tag.cRecipeBookAdd); + + /++ + + +/ + alias cRecipeBookRemove = _create!(Tag.cRecipeBookRemove); + /// ditto + pragma(inline, true) bool isCRecipeBookRemove() const => _tag == Tag.cRecipeBookRemove; + ///ditto + alias getCRecipeBookRemove = _get!(Tag.cRecipeBookRemove); + + /++ + + +/ + alias cRecipeBookSettings = _create!(Tag.cRecipeBookSettings); + /// ditto + pragma(inline, true) bool isCRecipeBookSettings() const => _tag == Tag.cRecipeBookSettings; + ///ditto + alias getCRecipeBookSettings = _get!(Tag.cRecipeBookSettings); + + /++ + + +/ + alias cRemoveEntities = _create!(Tag.cRemoveEntities); + /// ditto + pragma(inline, true) bool isCRemoveEntities() const => _tag == Tag.cRemoveEntities; + ///ditto + alias getCRemoveEntities = _get!(Tag.cRemoveEntities); + + /++ + + +/ + alias cRemoveMobEffect = _create!(Tag.cRemoveMobEffect); + /// ditto + pragma(inline, true) bool isCRemoveMobEffect() const => _tag == Tag.cRemoveMobEffect; + ///ditto + alias getCRemoveMobEffect = _get!(Tag.cRemoveMobEffect); + + /++ + + +/ + alias cRemoveResourcePack = _create!(Tag.cRemoveResourcePack); + /// ditto + pragma(inline, true) bool isCRemoveResourcePack() const => _tag == Tag.cRemoveResourcePack; + ///ditto + alias getCRemoveResourcePack = _get!(Tag.cRemoveResourcePack); + + /++ + + +/ + alias cResetScore = _create!(Tag.cResetScore); + /// ditto + pragma(inline, true) bool isCResetScore() const => _tag == Tag.cResetScore; + ///ditto + alias getCResetScore = _get!(Tag.cResetScore); + + /++ + + +/ + alias cRespawn = _create!(Tag.cRespawn); + /// ditto + pragma(inline, true) bool isCRespawn() const => _tag == Tag.cRespawn; + ///ditto + alias getCRespawn = _get!(Tag.cRespawn); + + /++ + + +/ + alias cSelectAdvancementsTab = _create!(Tag.cSelectAdvancementsTab); + /// ditto + pragma(inline, true) bool isCSelectAdvancementsTab() const => _tag == Tag.cSelectAdvancementsTab; + ///ditto + alias getCSelectAdvancementsTab = _get!(Tag.cSelectAdvancementsTab); + + /++ + + +/ + alias cServerData = _create!(Tag.cServerData); + /// ditto + pragma(inline, true) bool isCServerData() const => _tag == Tag.cServerData; + ///ditto + alias getCServerData = _get!(Tag.cServerData); + + /++ + + +/ + alias cPlayServerLinks = _create!(Tag.cPlayServerLinks); + /// ditto + pragma(inline, true) bool isCPlayServerLinks() const => _tag == Tag.cPlayServerLinks; + ///ditto + alias getCPlayServerLinks = _get!(Tag.cPlayServerLinks); + + /++ + + +/ + alias cSetBorderCenter = _create!(Tag.cSetBorderCenter); + /// ditto + pragma(inline, true) bool isCSetBorderCenter() const => _tag == Tag.cSetBorderCenter; + ///ditto + alias getCSetBorderCenter = _get!(Tag.cSetBorderCenter); + + /++ + + +/ + alias cSetBorderLerpSize = _create!(Tag.cSetBorderLerpSize); + /// ditto + pragma(inline, true) bool isCSetBorderLerpSize() const => _tag == Tag.cSetBorderLerpSize; + ///ditto + alias getCSetBorderLerpSize = _get!(Tag.cSetBorderLerpSize); + + /++ + + +/ + alias cSetBorderSize = _create!(Tag.cSetBorderSize); + /// ditto + pragma(inline, true) bool isCSetBorderSize() const => _tag == Tag.cSetBorderSize; + ///ditto + alias getCSetBorderSize = _get!(Tag.cSetBorderSize); + + /++ + + +/ + alias cSetBorderWarningDelay = _create!(Tag.cSetBorderWarningDelay); + /// ditto + pragma(inline, true) bool isCSetBorderWarningDelay() const => _tag == Tag.cSetBorderWarningDelay; + ///ditto + alias getCSetBorderWarningDelay = _get!(Tag.cSetBorderWarningDelay); + + /++ + + +/ + alias cSetBorderWarningDistance = _create!(Tag.cSetBorderWarningDistance); + /// ditto + pragma(inline, true) bool isCSetBorderWarningDistance() const => _tag == Tag.cSetBorderWarningDistance; + ///ditto + alias getCSetBorderWarningDistance = _get!(Tag.cSetBorderWarningDistance); + + /++ + + +/ + alias cSetCamera = _create!(Tag.cSetCamera); + /// ditto + pragma(inline, true) bool isCSetCamera() const => _tag == Tag.cSetCamera; + ///ditto + alias getCSetCamera = _get!(Tag.cSetCamera); + + /++ + + +/ + alias cSetChunkCacheRadius = _create!(Tag.cSetChunkCacheRadius); + /// ditto + pragma(inline, true) bool isCSetChunkCacheRadius() const => _tag == Tag.cSetChunkCacheRadius; + ///ditto + alias getCSetChunkCacheRadius = _get!(Tag.cSetChunkCacheRadius); + + /++ + + +/ + alias cSetContainerContent = _create!(Tag.cSetContainerContent); + /// ditto + pragma(inline, true) bool isCSetContainerContent() const => _tag == Tag.cSetContainerContent; + ///ditto + alias getCSetContainerContent = _get!(Tag.cSetContainerContent); + + /++ + + +/ + alias cSetContainerProperty = _create!(Tag.cSetContainerProperty); + /// ditto + pragma(inline, true) bool isCSetContainerProperty() const => _tag == Tag.cSetContainerProperty; + ///ditto + alias getCSetContainerProperty = _get!(Tag.cSetContainerProperty); + + /++ + + +/ + alias cSetContainerSlot = _create!(Tag.cSetContainerSlot); + /// ditto + pragma(inline, true) bool isCSetContainerSlot() const => _tag == Tag.cSetContainerSlot; + ///ditto + alias getCSetContainerSlot = _get!(Tag.cSetContainerSlot); + + /++ + + +/ + alias cSetCursorItem = _create!(Tag.cSetCursorItem); + /// ditto + pragma(inline, true) bool isCSetCursorItem() const => _tag == Tag.cSetCursorItem; + ///ditto + alias getCSetCursorItem = _get!(Tag.cSetCursorItem); + + /++ + + +/ + alias cSetEntityLink = _create!(Tag.cSetEntityLink); + /// ditto + pragma(inline, true) bool isCSetEntityLink() const => _tag == Tag.cSetEntityLink; + ///ditto + alias getCSetEntityLink = _get!(Tag.cSetEntityLink); + + /++ + + +/ + alias cSetEquipment = _create!(Tag.cSetEquipment); + /// ditto + pragma(inline, true) bool isCSetEquipment() const => _tag == Tag.cSetEquipment; + ///ditto + alias getCSetEquipment = _get!(Tag.cSetEquipment); + + /++ + + +/ + alias cSetExperience = _create!(Tag.cSetExperience); + /// ditto + pragma(inline, true) bool isCSetExperience() const => _tag == Tag.cSetExperience; + ///ditto + alias getCSetExperience = _get!(Tag.cSetExperience); + + /++ + + +/ + alias cSetHealth = _create!(Tag.cSetHealth); + /// ditto + pragma(inline, true) bool isCSetHealth() const => _tag == Tag.cSetHealth; + ///ditto + alias getCSetHealth = _get!(Tag.cSetHealth); + + /++ + + +/ + alias cSetPassengers = _create!(Tag.cSetPassengers); + /// ditto + pragma(inline, true) bool isCSetPassengers() const => _tag == Tag.cSetPassengers; + ///ditto + alias getCSetPassengers = _get!(Tag.cSetPassengers); + + /++ + + +/ + alias cSetPlayerInventory = _create!(Tag.cSetPlayerInventory); + /// ditto + pragma(inline, true) bool isCSetPlayerInventory() const => _tag == Tag.cSetPlayerInventory; + ///ditto + alias getCSetPlayerInventory = _get!(Tag.cSetPlayerInventory); + + /++ + + +/ + alias cSetPlayerTeam = _create!(Tag.cSetPlayerTeam); + /// ditto + pragma(inline, true) bool isCSetPlayerTeam() const => _tag == Tag.cSetPlayerTeam; + ///ditto + alias getCSetPlayerTeam = _get!(Tag.cSetPlayerTeam); + + /++ + + +/ + alias cSetSimulationDistance = _create!(Tag.cSetSimulationDistance); + /// ditto + pragma(inline, true) bool isCSetSimulationDistance() const => _tag == Tag.cSetSimulationDistance; + ///ditto + alias getCSetSimulationDistance = _get!(Tag.cSetSimulationDistance); + + /++ + + +/ + alias cUpdateTime = _create!(Tag.cUpdateTime); + /// ditto + pragma(inline, true) bool isCUpdateTime() const => _tag == Tag.cUpdateTime; + ///ditto + alias getCUpdateTime = _get!(Tag.cUpdateTime); + + /++ + + +/ + alias cTitleText = _create!(Tag.cTitleText); + /// ditto + pragma(inline, true) bool isCTitleText() const => _tag == Tag.cTitleText; + ///ditto + alias getCTitleText = _get!(Tag.cTitleText); + + /++ + + +/ + alias cTitleAnimation = _create!(Tag.cTitleAnimation); + /// ditto + pragma(inline, true) bool isCTitleAnimation() const => _tag == Tag.cTitleAnimation; + ///ditto + alias getCTitleAnimation = _get!(Tag.cTitleAnimation); + + /++ + + +/ + alias cPlayShowDialog = _create!(Tag.cPlayShowDialog); + /// ditto + pragma(inline, true) bool isCPlayShowDialog() const => _tag == Tag.cPlayShowDialog; + ///ditto + alias getCPlayShowDialog = _get!(Tag.cPlayShowDialog); + + /++ + + +/ + alias cSoundEffect = _create!(Tag.cSoundEffect); + /// ditto + pragma(inline, true) bool isCSoundEffect() const => _tag == Tag.cSoundEffect; + ///ditto + alias getCSoundEffect = _get!(Tag.cSoundEffect); + + /++ + + +/ + alias cSpawnEntity = _create!(Tag.cSpawnEntity); + /// ditto + pragma(inline, true) bool isCSpawnEntity() const => _tag == Tag.cSpawnEntity; + ///ditto + alias getCSpawnEntity = _get!(Tag.cSpawnEntity); + + /++ + + +/ + alias cSpawnLivingEntity = _create!(Tag.cSpawnLivingEntity); + /// ditto + pragma(inline, true) bool isCSpawnLivingEntity() const => _tag == Tag.cSpawnLivingEntity; + ///ditto + alias getCSpawnLivingEntity = _get!(Tag.cSpawnLivingEntity); + + /++ + + +/ + alias cSpawnPainting = _create!(Tag.cSpawnPainting); + /// ditto + pragma(inline, true) bool isCSpawnPainting() const => _tag == Tag.cSpawnPainting; + ///ditto + alias getCSpawnPainting = _get!(Tag.cSpawnPainting); + + /++ + + +/ + alias cStartConfiguration = _create!(Tag.cStartConfiguration); + /// ditto + pragma(inline, true) bool isCStartConfiguration() const => _tag == Tag.cStartConfiguration; + + /++ + + +/ + alias cStopSound = _create!(Tag.cStopSound); + /// ditto + pragma(inline, true) bool isCStopSound() const => _tag == Tag.cStopSound; + ///ditto + alias getCStopSound = _get!(Tag.cStopSound); + + /++ + + +/ + alias cStoreCookie = _create!(Tag.cStoreCookie); + /// ditto + pragma(inline, true) bool isCStoreCookie() const => _tag == Tag.cStoreCookie; + ///ditto + alias getCStoreCookie = _get!(Tag.cStoreCookie); + + /++ + + +/ + alias cSubtitle = _create!(Tag.cSubtitle); + /// ditto + pragma(inline, true) bool isCSubtitle() const => _tag == Tag.cSubtitle; + ///ditto + alias getCSubtitle = _get!(Tag.cSubtitle); + + /++ + + +/ + alias cTabList = _create!(Tag.cTabList); + /// ditto + pragma(inline, true) bool isCTabList() const => _tag == Tag.cTabList; + ///ditto + alias getCTabList = _get!(Tag.cTabList); + + /++ + + +/ + alias cTagQueryResponse = _create!(Tag.cTagQueryResponse); + /// ditto + pragma(inline, true) bool isCTagQueryResponse() const => _tag == Tag.cTagQueryResponse; + ///ditto + alias getCTagQueryResponse = _get!(Tag.cTagQueryResponse); + + /++ + + +/ + alias cTakeItemEntity = _create!(Tag.cTakeItemEntity); + /// ditto + pragma(inline, true) bool isCTakeItemEntity() const => _tag == Tag.cTakeItemEntity; + ///ditto + alias getCTakeItemEntity = _get!(Tag.cTakeItemEntity); + + /++ + + +/ + alias cTeleportEntity = _create!(Tag.cTeleportEntity); + /// ditto + pragma(inline, true) bool isCTeleportEntity() const => _tag == Tag.cTeleportEntity; + ///ditto + alias getCTeleportEntity = _get!(Tag.cTeleportEntity); + + /++ + + +/ + alias cTestInstanceBlockStatus = _create!(Tag.cTestInstanceBlockStatus); + /// ditto + pragma(inline, true) bool isCTestInstanceBlockStatus() const => _tag == Tag.cTestInstanceBlockStatus; + ///ditto + alias getCTestInstanceBlockStatus = _get!(Tag.cTestInstanceBlockStatus); + + /++ + + +/ + alias cTickingState = _create!(Tag.cTickingState); + /// ditto + pragma(inline, true) bool isCTickingState() const => _tag == Tag.cTickingState; + ///ditto + alias getCTickingState = _get!(Tag.cTickingState); + + /++ + + +/ + alias cTickingStep = _create!(Tag.cTickingStep); + /// ditto + pragma(inline, true) bool isCTickingStep() const => _tag == Tag.cTickingStep; + ///ditto + alias getCTickingStep = _get!(Tag.cTickingStep); + + /++ + + +/ + alias cTransfer = _create!(Tag.cTransfer); + /// ditto + pragma(inline, true) bool isCTransfer() const => _tag == Tag.cTransfer; + ///ditto + alias getCTransfer = _get!(Tag.cTransfer); + + /++ + + +/ + alias cUnloadChunk = _create!(Tag.cUnloadChunk); + /// ditto + pragma(inline, true) bool isCUnloadChunk() const => _tag == Tag.cUnloadChunk; + ///ditto + alias getCUnloadChunk = _get!(Tag.cUnloadChunk); + + /++ + + +/ + alias cUpdateAdvancements = _create!(Tag.cUpdateAdvancements); + /// ditto + pragma(inline, true) bool isCUpdateAdvancements() const => _tag == Tag.cUpdateAdvancements; + ///ditto + alias getCUpdateAdvancements = _get!(Tag.cUpdateAdvancements); + + /++ + + +/ + alias cUpdateAttributes = _create!(Tag.cUpdateAttributes); + /// ditto + pragma(inline, true) bool isCUpdateAttributes() const => _tag == Tag.cUpdateAttributes; + ///ditto + alias getCUpdateAttributes = _get!(Tag.cUpdateAttributes); + + /++ + + +/ + alias cUpdateEntityPos = _create!(Tag.cUpdateEntityPos); + /// ditto + pragma(inline, true) bool isCUpdateEntityPos() const => _tag == Tag.cUpdateEntityPos; + ///ditto + alias getCUpdateEntityPos = _get!(Tag.cUpdateEntityPos); + + /++ + + +/ + alias cUpdateEntityPosRot = _create!(Tag.cUpdateEntityPosRot); + /// ditto + pragma(inline, true) bool isCUpdateEntityPosRot() const => _tag == Tag.cUpdateEntityPosRot; + ///ditto + alias getCUpdateEntityPosRot = _get!(Tag.cUpdateEntityPosRot); + + /++ + + +/ + alias cUpdateEntityRot = _create!(Tag.cUpdateEntityRot); + /// ditto + pragma(inline, true) bool isCUpdateEntityRot() const => _tag == Tag.cUpdateEntityRot; + ///ditto + alias getCUpdateEntityRot = _get!(Tag.cUpdateEntityRot); + + /++ + + +/ + alias cUpdateMobEffect = _create!(Tag.cUpdateMobEffect); + /// ditto + pragma(inline, true) bool isCUpdateMobEffect() const => _tag == Tag.cUpdateMobEffect; + ///ditto + alias getCUpdateMobEffect = _get!(Tag.cUpdateMobEffect); + + /++ + + +/ + alias cUpdateObjectives = _create!(Tag.cUpdateObjectives); + /// ditto + pragma(inline, true) bool isCUpdateObjectives() const => _tag == Tag.cUpdateObjectives; + ///ditto + alias getCUpdateObjectives = _get!(Tag.cUpdateObjectives); + + /++ + + +/ + alias cUpdateRecipes = _create!(Tag.cUpdateRecipes); + /// ditto + pragma(inline, true) bool isCUpdateRecipes() const => _tag == Tag.cUpdateRecipes; + ///ditto + alias getCUpdateRecipes = _get!(Tag.cUpdateRecipes); + + /++ + + +/ + alias cUpdateScore = _create!(Tag.cUpdateScore); + /// ditto + pragma(inline, true) bool isCUpdateScore() const => _tag == Tag.cUpdateScore; + ///ditto + alias getCUpdateScore = _get!(Tag.cUpdateScore); + + /++ + + +/ + alias cUseBed = _create!(Tag.cUseBed); + /// ditto + pragma(inline, true) bool isCUseBed() const => _tag == Tag.cUseBed; + ///ditto + alias getCUseBed = _get!(Tag.cUseBed); + + /++ + + +/ + alias cWaypoint = _create!(Tag.cWaypoint); + /// ditto + pragma(inline, true) bool isCWaypoint() const => _tag == Tag.cWaypoint; + ///ditto + alias getCWaypoint = _get!(Tag.cWaypoint); + + /++ + + +/ + alias cWorldEvent = _create!(Tag.cWorldEvent); + /// ditto + pragma(inline, true) bool isCWorldEvent() const => _tag == Tag.cWorldEvent; + ///ditto + alias getCWorldEvent = _get!(Tag.cWorldEvent); + + /++ + + +/ + alias statusCPingResponse = _create!(Tag.statusCPingResponse); + /// ditto + pragma(inline, true) bool isStatusCPingResponse() const => _tag == Tag.statusCPingResponse; + ///ditto + alias getStatusCPingResponse = _get!(Tag.statusCPingResponse); + + /++ + + +/ + alias statusCStatusResponse = _create!(Tag.statusCStatusResponse); + /// ditto + pragma(inline, true) bool isStatusCStatusResponse() const => _tag == Tag.statusCStatusResponse; + ///ditto + alias getStatusCStatusResponse = _get!(Tag.statusCStatusResponse); + + /++ + + +/ + alias unknown = _create!(Tag.unknown); + /// ditto + pragma(inline, true) bool isUnknown() const => _tag == Tag.unknown; + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case configCConfigAddResourcePack: _get!(Tag.configCConfigAddResourcePack).witFree; break; + case configCCodeOfConduct: _get!(Tag.configCCodeOfConduct).witFree; break; + case configCConfigDisconnect: _get!(Tag.configCConfigDisconnect).witFree; break; + case configCCookieRequest: _get!(Tag.configCCookieRequest).witFree; break; + case configCConfigCustomReportDetails: _get!(Tag.configCConfigCustomReportDetails).witFree; break; + case configCFeatureFlags: _get!(Tag.configCFeatureFlags).witFree; break; + case configCKnownPacks: _get!(Tag.configCKnownPacks).witFree; break; + case configCPluginMessage: _get!(Tag.configCPluginMessage).witFree; break; + case configCRegistryData: _get!(Tag.configCRegistryData).witFree; break; + case configCConfigServerLinks: _get!(Tag.configCConfigServerLinks).witFree; break; + case configCConfigShowDialog: _get!(Tag.configCConfigShowDialog).witFree; break; + case configCStoreCookie: _get!(Tag.configCStoreCookie).witFree; break; + case configCTransfer: _get!(Tag.configCTransfer).witFree; break; + case configCUpdateTags: _get!(Tag.configCUpdateTags).witFree; break; + case loginCLoginCookieRequest: _get!(Tag.loginCLoginCookieRequest).witFree; break; + case loginCLoginDisconnect: _get!(Tag.loginCLoginDisconnect).witFree; break; + case loginCLoginPluginRequest: _get!(Tag.loginCLoginPluginRequest).witFree; break; + case cActionBar: _get!(Tag.cActionBar).witFree; break; + case cAddResourcePack: _get!(Tag.cAddResourcePack).witFree; break; + case cAwardStats: _get!(Tag.cAwardStats).witFree; break; + case cBlockEntityData: _get!(Tag.cBlockEntityData).witFree; break; + case cBossEvent: _get!(Tag.cBossEvent).witFree; break; + case cChunksBiomes: _get!(Tag.cChunksBiomes).witFree; break; + case cCombatDeath: _get!(Tag.cCombatDeath).witFree; break; + case cCommandSuggestions: _get!(Tag.cCommandSuggestions).witFree; break; + case cCommands: _get!(Tag.cCommands).witFree; break; + case cPlayCookieRequest: _get!(Tag.cPlayCookieRequest).witFree; break; + case cCustomChatCompletions: _get!(Tag.cCustomChatCompletions).witFree; break; + case cCustomPayload: _get!(Tag.cCustomPayload).witFree; break; + case cPlayCustomReportDetails: _get!(Tag.cPlayCustomReportDetails).witFree; break; + case cDebugBlockValue: _get!(Tag.cDebugBlockValue).witFree; break; + case cDebugChunkValue: _get!(Tag.cDebugChunkValue).witFree; break; + case cDebugEntityValue: _get!(Tag.cDebugEntityValue).witFree; break; + case cDebugEvent: _get!(Tag.cDebugEvent).witFree; break; + case cDebugSample: _get!(Tag.cDebugSample).witFree; break; + case cDeleteChat: _get!(Tag.cDeleteChat).witFree; break; + case cPlayDisconnect: _get!(Tag.cPlayDisconnect).witFree; break; + case cDisguisedChatMessage: _get!(Tag.cDisguisedChatMessage).witFree; break; + case cDisplayObjective: _get!(Tag.cDisplayObjective).witFree; break; + case cSetEntityMetadata: _get!(Tag.cSetEntityMetadata).witFree; break; + case cEntitySoundEffect: _get!(Tag.cEntitySoundEffect).witFree; break; + case cEntityVelocity: _get!(Tag.cEntityVelocity).witFree; break; + case cExplosion: _get!(Tag.cExplosion).witFree; break; + case cGameRuleValues: _get!(Tag.cGameRuleValues).witFree; break; + case cGameTestHighlightPos: _get!(Tag.cGameTestHighlightPos).witFree; break; + case cItemCooldown: _get!(Tag.cItemCooldown).witFree; break; + case cLightUpdate: _get!(Tag.cLightUpdate).witFree; break; + case cLogin: _get!(Tag.cLogin).witFree; break; + case cMapItemData: _get!(Tag.cMapItemData).witFree; break; + case cMerchantOffers: _get!(Tag.cMerchantOffers).witFree; break; + case cMoveMinecartAlongTrack: _get!(Tag.cMoveMinecartAlongTrack).witFree; break; + case cMultiBlockUpdate: _get!(Tag.cMultiBlockUpdate).witFree; break; + case cOpenScreen: _get!(Tag.cOpenScreen).witFree; break; + case cParticle: _get!(Tag.cParticle).witFree; break; + case cPlaceGhostRecipe: _get!(Tag.cPlaceGhostRecipe).witFree; break; + case cPlayerChatMessage: _get!(Tag.cPlayerChatMessage).witFree; break; + case cPlayerInfoUpdate: _get!(Tag.cPlayerInfoUpdate).witFree; break; + case cPlayerPosition: _get!(Tag.cPlayerPosition).witFree; break; + case cRemovePlayerInfo: _get!(Tag.cRemovePlayerInfo).witFree; break; + case cPlayerSpawnPosition: _get!(Tag.cPlayerSpawnPosition).witFree; break; + case cRecipeBookRemove: _get!(Tag.cRecipeBookRemove).witFree; break; + case cRemoveEntities: _get!(Tag.cRemoveEntities).witFree; break; + case cResetScore: _get!(Tag.cResetScore).witFree; break; + case cRespawn: _get!(Tag.cRespawn).witFree; break; + case cSelectAdvancementsTab: _get!(Tag.cSelectAdvancementsTab).witFree; break; + case cServerData: _get!(Tag.cServerData).witFree; break; + case cPlayServerLinks: _get!(Tag.cPlayServerLinks).witFree; break; + case cSetContainerContent: _get!(Tag.cSetContainerContent).witFree; break; + case cSetContainerSlot: _get!(Tag.cSetContainerSlot).witFree; break; + case cSetCursorItem: _get!(Tag.cSetCursorItem).witFree; break; + case cSetEquipment: _get!(Tag.cSetEquipment).witFree; break; + case cSetPassengers: _get!(Tag.cSetPassengers).witFree; break; + case cSetPlayerInventory: _get!(Tag.cSetPlayerInventory).witFree; break; + case cSetPlayerTeam: _get!(Tag.cSetPlayerTeam).witFree; break; + case cUpdateTime: _get!(Tag.cUpdateTime).witFree; break; + case cTitleText: _get!(Tag.cTitleText).witFree; break; + case cPlayShowDialog: _get!(Tag.cPlayShowDialog).witFree; break; + case cSoundEffect: _get!(Tag.cSoundEffect).witFree; break; + case cSpawnEntity: _get!(Tag.cSpawnEntity).witFree; break; + case cSpawnLivingEntity: _get!(Tag.cSpawnLivingEntity).witFree; break; + case cSpawnPainting: _get!(Tag.cSpawnPainting).witFree; break; + case cStopSound: _get!(Tag.cStopSound).witFree; break; + case cStoreCookie: _get!(Tag.cStoreCookie).witFree; break; + case cSubtitle: _get!(Tag.cSubtitle).witFree; break; + case cTabList: _get!(Tag.cTabList).witFree; break; + case cTagQueryResponse: _get!(Tag.cTagQueryResponse).witFree; break; + case cTeleportEntity: _get!(Tag.cTeleportEntity).witFree; break; + case cTestInstanceBlockStatus: _get!(Tag.cTestInstanceBlockStatus).witFree; break; + case cTransfer: _get!(Tag.cTransfer).witFree; break; + case cUpdateAdvancements: _get!(Tag.cUpdateAdvancements).witFree; break; + case cUpdateAttributes: _get!(Tag.cUpdateAttributes).witFree; break; + case cUpdateObjectives: _get!(Tag.cUpdateObjectives).witFree; break; + case cUpdateRecipes: _get!(Tag.cUpdateRecipes).witFree; break; + case cUpdateScore: _get!(Tag.cUpdateScore).witFree; break; + case cWaypoint: _get!(Tag.cWaypoint).witFree; break; + case statusCStatusResponse: _get!(Tag.statusCStatusResponse).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + } + + ClientboundPacket witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.configCConfigAddResourcePack: return _create!(Tag.configCConfigAddResourcePack)(this._get!(Tag.configCConfigAddResourcePack).witClone); break; + case Tag.configCConfigClearDialog: return _create!(Tag.configCConfigClearDialog); break; + case Tag.configCCodeOfConduct: return _create!(Tag.configCCodeOfConduct)(this._get!(Tag.configCCodeOfConduct).witClone); break; + case Tag.configCConfigDisconnect: return _create!(Tag.configCConfigDisconnect)(this._get!(Tag.configCConfigDisconnect).witClone); break; + case Tag.configCCookieRequest: return _create!(Tag.configCCookieRequest)(this._get!(Tag.configCCookieRequest).witClone); break; + case Tag.configCConfigCustomReportDetails: return _create!(Tag.configCConfigCustomReportDetails)(this._get!(Tag.configCConfigCustomReportDetails).witClone); break; + case Tag.configCFeatureFlags: return _create!(Tag.configCFeatureFlags)(this._get!(Tag.configCFeatureFlags).witClone); break; + case Tag.configCFinishConfig: return _create!(Tag.configCFinishConfig); break; + case Tag.configCKnownPacks: return _create!(Tag.configCKnownPacks)(this._get!(Tag.configCKnownPacks).witClone); break; + case Tag.configCConfigPing: return _create!(Tag.configCConfigPing)(this._get!(Tag.configCConfigPing).witClone); break; + case Tag.configCPluginMessage: return _create!(Tag.configCPluginMessage)(this._get!(Tag.configCPluginMessage).witClone); break; + case Tag.configCRegistryData: return _create!(Tag.configCRegistryData)(this._get!(Tag.configCRegistryData).witClone); break; + case Tag.configCConfigRemoveResourcePack: return _create!(Tag.configCConfigRemoveResourcePack)(this._get!(Tag.configCConfigRemoveResourcePack).witClone); break; + case Tag.configCConfigResetChat: return _create!(Tag.configCConfigResetChat); break; + case Tag.configCConfigServerLinks: return _create!(Tag.configCConfigServerLinks)(this._get!(Tag.configCConfigServerLinks).witClone); break; + case Tag.configCConfigShowDialog: return _create!(Tag.configCConfigShowDialog)(this._get!(Tag.configCConfigShowDialog).witClone); break; + case Tag.configCStoreCookie: return _create!(Tag.configCStoreCookie)(this._get!(Tag.configCStoreCookie).witClone); break; + case Tag.configCTransfer: return _create!(Tag.configCTransfer)(this._get!(Tag.configCTransfer).witClone); break; + case Tag.configCUpdateTags: return _create!(Tag.configCUpdateTags)(this._get!(Tag.configCUpdateTags).witClone); break; + case Tag.loginCLoginCookieRequest: return _create!(Tag.loginCLoginCookieRequest)(this._get!(Tag.loginCLoginCookieRequest).witClone); break; + case Tag.loginCLoginDisconnect: return _create!(Tag.loginCLoginDisconnect)(this._get!(Tag.loginCLoginDisconnect).witClone); break; + case Tag.loginCLoginPluginRequest: return _create!(Tag.loginCLoginPluginRequest)(this._get!(Tag.loginCLoginPluginRequest).witClone); break; + case Tag.loginCSetCompression: return _create!(Tag.loginCSetCompression)(this._get!(Tag.loginCSetCompression).witClone); break; + case Tag.cAcknowledgeBlockChange: return _create!(Tag.cAcknowledgeBlockChange)(this._get!(Tag.cAcknowledgeBlockChange).witClone); break; + case Tag.cActionBar: return _create!(Tag.cActionBar)(this._get!(Tag.cActionBar).witClone); break; + case Tag.cAddResourcePack: return _create!(Tag.cAddResourcePack)(this._get!(Tag.cAddResourcePack).witClone); break; + case Tag.cAwardStats: return _create!(Tag.cAwardStats)(this._get!(Tag.cAwardStats).witClone); break; + case Tag.cSetBlockDestroyStage: return _create!(Tag.cSetBlockDestroyStage)(this._get!(Tag.cSetBlockDestroyStage).witClone); break; + case Tag.cBlockEntityData: return _create!(Tag.cBlockEntityData)(this._get!(Tag.cBlockEntityData).witClone); break; + case Tag.cBlockEvent: return _create!(Tag.cBlockEvent)(this._get!(Tag.cBlockEvent).witClone); break; + case Tag.cBlockUpdate: return _create!(Tag.cBlockUpdate)(this._get!(Tag.cBlockUpdate).witClone); break; + case Tag.cBossEvent: return _create!(Tag.cBossEvent)(this._get!(Tag.cBossEvent).witClone); break; + case Tag.cBundleDelimiter: return _create!(Tag.cBundleDelimiter); break; + case Tag.cCenterChunk: return _create!(Tag.cCenterChunk)(this._get!(Tag.cCenterChunk).witClone); break; + case Tag.cChangeDifficulty: return _create!(Tag.cChangeDifficulty)(this._get!(Tag.cChangeDifficulty).witClone); break; + case Tag.cChunkBatchEnd: return _create!(Tag.cChunkBatchEnd)(this._get!(Tag.cChunkBatchEnd).witClone); break; + case Tag.cChunkBatchStart: return _create!(Tag.cChunkBatchStart); break; + case Tag.cChunksBiomes: return _create!(Tag.cChunksBiomes)(this._get!(Tag.cChunksBiomes).witClone); break; + case Tag.cPlayClearDialog: return _create!(Tag.cPlayClearDialog); break; + case Tag.cClearTitle: return _create!(Tag.cClearTitle)(this._get!(Tag.cClearTitle).witClone); break; + case Tag.cCloseContainer: return _create!(Tag.cCloseContainer)(this._get!(Tag.cCloseContainer).witClone); break; + case Tag.cCombatDeath: return _create!(Tag.cCombatDeath)(this._get!(Tag.cCombatDeath).witClone); break; + case Tag.cCombatEnter: return _create!(Tag.cCombatEnter); break; + case Tag.cCombatEnd: return _create!(Tag.cCombatEnd)(this._get!(Tag.cCombatEnd).witClone); break; + case Tag.cCommandSuggestions: return _create!(Tag.cCommandSuggestions)(this._get!(Tag.cCommandSuggestions).witClone); break; + case Tag.cCommands: return _create!(Tag.cCommands)(this._get!(Tag.cCommands).witClone); break; + case Tag.cPlayCookieRequest: return _create!(Tag.cPlayCookieRequest)(this._get!(Tag.cPlayCookieRequest).witClone); break; + case Tag.cCustomChatCompletions: return _create!(Tag.cCustomChatCompletions)(this._get!(Tag.cCustomChatCompletions).witClone); break; + case Tag.cCustomPayload: return _create!(Tag.cCustomPayload)(this._get!(Tag.cCustomPayload).witClone); break; + case Tag.cPlayCustomReportDetails: return _create!(Tag.cPlayCustomReportDetails)(this._get!(Tag.cPlayCustomReportDetails).witClone); break; + case Tag.cDamageEvent: return _create!(Tag.cDamageEvent)(this._get!(Tag.cDamageEvent).witClone); break; + case Tag.cDebugBlockValue: return _create!(Tag.cDebugBlockValue)(this._get!(Tag.cDebugBlockValue).witClone); break; + case Tag.cDebugChunkValue: return _create!(Tag.cDebugChunkValue)(this._get!(Tag.cDebugChunkValue).witClone); break; + case Tag.cDebugEntityValue: return _create!(Tag.cDebugEntityValue)(this._get!(Tag.cDebugEntityValue).witClone); break; + case Tag.cDebugEvent: return _create!(Tag.cDebugEvent)(this._get!(Tag.cDebugEvent).witClone); break; + case Tag.cDebugSample: return _create!(Tag.cDebugSample)(this._get!(Tag.cDebugSample).witClone); break; + case Tag.cDeleteChat: return _create!(Tag.cDeleteChat)(this._get!(Tag.cDeleteChat).witClone); break; + case Tag.cPlayDisconnect: return _create!(Tag.cPlayDisconnect)(this._get!(Tag.cPlayDisconnect).witClone); break; + case Tag.cDisguisedChatMessage: return _create!(Tag.cDisguisedChatMessage)(this._get!(Tag.cDisguisedChatMessage).witClone); break; + case Tag.cDisplayObjective: return _create!(Tag.cDisplayObjective)(this._get!(Tag.cDisplayObjective).witClone); break; + case Tag.cEntityAnimation: return _create!(Tag.cEntityAnimation)(this._get!(Tag.cEntityAnimation).witClone); break; + case Tag.cSetEntityMetadata: return _create!(Tag.cSetEntityMetadata)(this._get!(Tag.cSetEntityMetadata).witClone); break; + case Tag.cEntitySoundEffect: return _create!(Tag.cEntitySoundEffect)(this._get!(Tag.cEntitySoundEffect).witClone); break; + case Tag.cEntityStatus: return _create!(Tag.cEntityStatus)(this._get!(Tag.cEntityStatus).witClone); break; + case Tag.cEntityVelocity: return _create!(Tag.cEntityVelocity)(this._get!(Tag.cEntityVelocity).witClone); break; + case Tag.cExplosion: return _create!(Tag.cExplosion)(this._get!(Tag.cExplosion).witClone); break; + case Tag.cGameEvent: return _create!(Tag.cGameEvent)(this._get!(Tag.cGameEvent).witClone); break; + case Tag.cGameRuleValues: return _create!(Tag.cGameRuleValues)(this._get!(Tag.cGameRuleValues).witClone); break; + case Tag.cGameTestHighlightPos: return _create!(Tag.cGameTestHighlightPos)(this._get!(Tag.cGameTestHighlightPos).witClone); break; + case Tag.cHeadRot: return _create!(Tag.cHeadRot)(this._get!(Tag.cHeadRot).witClone); break; + case Tag.cHurtAnimation: return _create!(Tag.cHurtAnimation)(this._get!(Tag.cHurtAnimation).witClone); break; + case Tag.cInitializeWorldBorder: return _create!(Tag.cInitializeWorldBorder)(this._get!(Tag.cInitializeWorldBorder).witClone); break; + case Tag.cItemCooldown: return _create!(Tag.cItemCooldown)(this._get!(Tag.cItemCooldown).witClone); break; + case Tag.cKeepAlive: return _create!(Tag.cKeepAlive)(this._get!(Tag.cKeepAlive).witClone); break; + case Tag.cLevelEvent: return _create!(Tag.cLevelEvent)(this._get!(Tag.cLevelEvent).witClone); break; + case Tag.cLightUpdate: return _create!(Tag.cLightUpdate)(this._get!(Tag.cLightUpdate).witClone); break; + case Tag.cLogin: return _create!(Tag.cLogin)(this._get!(Tag.cLogin).witClone); break; + case Tag.cLowDiskSpaceWarning: return _create!(Tag.cLowDiskSpaceWarning); break; + case Tag.cMapItemData: return _create!(Tag.cMapItemData)(this._get!(Tag.cMapItemData).witClone); break; + case Tag.cMerchantOffers: return _create!(Tag.cMerchantOffers)(this._get!(Tag.cMerchantOffers).witClone); break; + case Tag.cMoveMinecartAlongTrack: return _create!(Tag.cMoveMinecartAlongTrack)(this._get!(Tag.cMoveMinecartAlongTrack).witClone); break; + case Tag.cMoveVehicle: return _create!(Tag.cMoveVehicle)(this._get!(Tag.cMoveVehicle).witClone); break; + case Tag.cMultiBlockUpdate: return _create!(Tag.cMultiBlockUpdate)(this._get!(Tag.cMultiBlockUpdate).witClone); break; + case Tag.cOpenBook: return _create!(Tag.cOpenBook)(this._get!(Tag.cOpenBook).witClone); break; + case Tag.cOpenMountScreen: return _create!(Tag.cOpenMountScreen)(this._get!(Tag.cOpenMountScreen).witClone); break; + case Tag.cOpenScreen: return _create!(Tag.cOpenScreen)(this._get!(Tag.cOpenScreen).witClone); break; + case Tag.cOpenSignEditor: return _create!(Tag.cOpenSignEditor)(this._get!(Tag.cOpenSignEditor).witClone); break; + case Tag.cParticle: return _create!(Tag.cParticle)(this._get!(Tag.cParticle).witClone); break; + case Tag.cPlayPing: return _create!(Tag.cPlayPing)(this._get!(Tag.cPlayPing).witClone); break; + case Tag.cPingResponse: return _create!(Tag.cPingResponse)(this._get!(Tag.cPingResponse).witClone); break; + case Tag.cPlaceGhostRecipe: return _create!(Tag.cPlaceGhostRecipe)(this._get!(Tag.cPlaceGhostRecipe).witClone); break; + case Tag.cPlayerAbilities: return _create!(Tag.cPlayerAbilities)(this._get!(Tag.cPlayerAbilities).witClone); break; + case Tag.cPlayerChatMessage: return _create!(Tag.cPlayerChatMessage)(this._get!(Tag.cPlayerChatMessage).witClone); break; + case Tag.cPlayerInfoUpdate: return _create!(Tag.cPlayerInfoUpdate)(this._get!(Tag.cPlayerInfoUpdate).witClone); break; + case Tag.cPlayerLookAt: return _create!(Tag.cPlayerLookAt)(this._get!(Tag.cPlayerLookAt).witClone); break; + case Tag.cPlayerPosition: return _create!(Tag.cPlayerPosition)(this._get!(Tag.cPlayerPosition).witClone); break; + case Tag.cRemovePlayerInfo: return _create!(Tag.cRemovePlayerInfo)(this._get!(Tag.cRemovePlayerInfo).witClone); break; + case Tag.cPlayerRotation: return _create!(Tag.cPlayerRotation)(this._get!(Tag.cPlayerRotation).witClone); break; + case Tag.cPlayerSpawnPosition: return _create!(Tag.cPlayerSpawnPosition)(this._get!(Tag.cPlayerSpawnPosition).witClone); break; + case Tag.cProjectilePower: return _create!(Tag.cProjectilePower)(this._get!(Tag.cProjectilePower).witClone); break; + case Tag.cRecipeBookAdd: return _create!(Tag.cRecipeBookAdd)(this._get!(Tag.cRecipeBookAdd).witClone); break; + case Tag.cRecipeBookRemove: return _create!(Tag.cRecipeBookRemove)(this._get!(Tag.cRecipeBookRemove).witClone); break; + case Tag.cRecipeBookSettings: return _create!(Tag.cRecipeBookSettings)(this._get!(Tag.cRecipeBookSettings).witClone); break; + case Tag.cRemoveEntities: return _create!(Tag.cRemoveEntities)(this._get!(Tag.cRemoveEntities).witClone); break; + case Tag.cRemoveMobEffect: return _create!(Tag.cRemoveMobEffect)(this._get!(Tag.cRemoveMobEffect).witClone); break; + case Tag.cRemoveResourcePack: return _create!(Tag.cRemoveResourcePack)(this._get!(Tag.cRemoveResourcePack).witClone); break; + case Tag.cResetScore: return _create!(Tag.cResetScore)(this._get!(Tag.cResetScore).witClone); break; + case Tag.cRespawn: return _create!(Tag.cRespawn)(this._get!(Tag.cRespawn).witClone); break; + case Tag.cSelectAdvancementsTab: return _create!(Tag.cSelectAdvancementsTab)(this._get!(Tag.cSelectAdvancementsTab).witClone); break; + case Tag.cServerData: return _create!(Tag.cServerData)(this._get!(Tag.cServerData).witClone); break; + case Tag.cPlayServerLinks: return _create!(Tag.cPlayServerLinks)(this._get!(Tag.cPlayServerLinks).witClone); break; + case Tag.cSetBorderCenter: return _create!(Tag.cSetBorderCenter)(this._get!(Tag.cSetBorderCenter).witClone); break; + case Tag.cSetBorderLerpSize: return _create!(Tag.cSetBorderLerpSize)(this._get!(Tag.cSetBorderLerpSize).witClone); break; + case Tag.cSetBorderSize: return _create!(Tag.cSetBorderSize)(this._get!(Tag.cSetBorderSize).witClone); break; + case Tag.cSetBorderWarningDelay: return _create!(Tag.cSetBorderWarningDelay)(this._get!(Tag.cSetBorderWarningDelay).witClone); break; + case Tag.cSetBorderWarningDistance: return _create!(Tag.cSetBorderWarningDistance)(this._get!(Tag.cSetBorderWarningDistance).witClone); break; + case Tag.cSetCamera: return _create!(Tag.cSetCamera)(this._get!(Tag.cSetCamera).witClone); break; + case Tag.cSetChunkCacheRadius: return _create!(Tag.cSetChunkCacheRadius)(this._get!(Tag.cSetChunkCacheRadius).witClone); break; + case Tag.cSetContainerContent: return _create!(Tag.cSetContainerContent)(this._get!(Tag.cSetContainerContent).witClone); break; + case Tag.cSetContainerProperty: return _create!(Tag.cSetContainerProperty)(this._get!(Tag.cSetContainerProperty).witClone); break; + case Tag.cSetContainerSlot: return _create!(Tag.cSetContainerSlot)(this._get!(Tag.cSetContainerSlot).witClone); break; + case Tag.cSetCursorItem: return _create!(Tag.cSetCursorItem)(this._get!(Tag.cSetCursorItem).witClone); break; + case Tag.cSetEntityLink: return _create!(Tag.cSetEntityLink)(this._get!(Tag.cSetEntityLink).witClone); break; + case Tag.cSetEquipment: return _create!(Tag.cSetEquipment)(this._get!(Tag.cSetEquipment).witClone); break; + case Tag.cSetExperience: return _create!(Tag.cSetExperience)(this._get!(Tag.cSetExperience).witClone); break; + case Tag.cSetHealth: return _create!(Tag.cSetHealth)(this._get!(Tag.cSetHealth).witClone); break; + case Tag.cSetPassengers: return _create!(Tag.cSetPassengers)(this._get!(Tag.cSetPassengers).witClone); break; + case Tag.cSetPlayerInventory: return _create!(Tag.cSetPlayerInventory)(this._get!(Tag.cSetPlayerInventory).witClone); break; + case Tag.cSetPlayerTeam: return _create!(Tag.cSetPlayerTeam)(this._get!(Tag.cSetPlayerTeam).witClone); break; + case Tag.cSetSimulationDistance: return _create!(Tag.cSetSimulationDistance)(this._get!(Tag.cSetSimulationDistance).witClone); break; + case Tag.cUpdateTime: return _create!(Tag.cUpdateTime)(this._get!(Tag.cUpdateTime).witClone); break; + case Tag.cTitleText: return _create!(Tag.cTitleText)(this._get!(Tag.cTitleText).witClone); break; + case Tag.cTitleAnimation: return _create!(Tag.cTitleAnimation)(this._get!(Tag.cTitleAnimation).witClone); break; + case Tag.cPlayShowDialog: return _create!(Tag.cPlayShowDialog)(this._get!(Tag.cPlayShowDialog).witClone); break; + case Tag.cSoundEffect: return _create!(Tag.cSoundEffect)(this._get!(Tag.cSoundEffect).witClone); break; + case Tag.cSpawnEntity: return _create!(Tag.cSpawnEntity)(this._get!(Tag.cSpawnEntity).witClone); break; + case Tag.cSpawnLivingEntity: return _create!(Tag.cSpawnLivingEntity)(this._get!(Tag.cSpawnLivingEntity).witClone); break; + case Tag.cSpawnPainting: return _create!(Tag.cSpawnPainting)(this._get!(Tag.cSpawnPainting).witClone); break; + case Tag.cStartConfiguration: return _create!(Tag.cStartConfiguration); break; + case Tag.cStopSound: return _create!(Tag.cStopSound)(this._get!(Tag.cStopSound).witClone); break; + case Tag.cStoreCookie: return _create!(Tag.cStoreCookie)(this._get!(Tag.cStoreCookie).witClone); break; + case Tag.cSubtitle: return _create!(Tag.cSubtitle)(this._get!(Tag.cSubtitle).witClone); break; + case Tag.cTabList: return _create!(Tag.cTabList)(this._get!(Tag.cTabList).witClone); break; + case Tag.cTagQueryResponse: return _create!(Tag.cTagQueryResponse)(this._get!(Tag.cTagQueryResponse).witClone); break; + case Tag.cTakeItemEntity: return _create!(Tag.cTakeItemEntity)(this._get!(Tag.cTakeItemEntity).witClone); break; + case Tag.cTeleportEntity: return _create!(Tag.cTeleportEntity)(this._get!(Tag.cTeleportEntity).witClone); break; + case Tag.cTestInstanceBlockStatus: return _create!(Tag.cTestInstanceBlockStatus)(this._get!(Tag.cTestInstanceBlockStatus).witClone); break; + case Tag.cTickingState: return _create!(Tag.cTickingState)(this._get!(Tag.cTickingState).witClone); break; + case Tag.cTickingStep: return _create!(Tag.cTickingStep)(this._get!(Tag.cTickingStep).witClone); break; + case Tag.cTransfer: return _create!(Tag.cTransfer)(this._get!(Tag.cTransfer).witClone); break; + case Tag.cUnloadChunk: return _create!(Tag.cUnloadChunk)(this._get!(Tag.cUnloadChunk).witClone); break; + case Tag.cUpdateAdvancements: return _create!(Tag.cUpdateAdvancements)(this._get!(Tag.cUpdateAdvancements).witClone); break; + case Tag.cUpdateAttributes: return _create!(Tag.cUpdateAttributes)(this._get!(Tag.cUpdateAttributes).witClone); break; + case Tag.cUpdateEntityPos: return _create!(Tag.cUpdateEntityPos)(this._get!(Tag.cUpdateEntityPos).witClone); break; + case Tag.cUpdateEntityPosRot: return _create!(Tag.cUpdateEntityPosRot)(this._get!(Tag.cUpdateEntityPosRot).witClone); break; + case Tag.cUpdateEntityRot: return _create!(Tag.cUpdateEntityRot)(this._get!(Tag.cUpdateEntityRot).witClone); break; + case Tag.cUpdateMobEffect: return _create!(Tag.cUpdateMobEffect)(this._get!(Tag.cUpdateMobEffect).witClone); break; + case Tag.cUpdateObjectives: return _create!(Tag.cUpdateObjectives)(this._get!(Tag.cUpdateObjectives).witClone); break; + case Tag.cUpdateRecipes: return _create!(Tag.cUpdateRecipes)(this._get!(Tag.cUpdateRecipes).witClone); break; + case Tag.cUpdateScore: return _create!(Tag.cUpdateScore)(this._get!(Tag.cUpdateScore).witClone); break; + case Tag.cUseBed: return _create!(Tag.cUseBed)(this._get!(Tag.cUseBed).witClone); break; + case Tag.cWaypoint: return _create!(Tag.cWaypoint)(this._get!(Tag.cWaypoint).witClone); break; + case Tag.cWorldEvent: return _create!(Tag.cWorldEvent)(this._get!(Tag.cWorldEvent).witClone); break; + case Tag.statusCPingResponse: return _create!(Tag.statusCPingResponse)(this._get!(Tag.statusCPingResponse).witClone); break; + case Tag.statusCStatusResponse: return _create!(Tag.statusCStatusResponse)(this._get!(Tag.statusCStatusResponse).witClone); break; + case Tag.unknown: return _create!(Tag.unknown); break; + } + } +} diff --git a/src/wit/pumpkin/plugin/java_packets/imports.d b/src/wit/pumpkin/plugin/java_packets/imports.d new file mode 100644 index 0000000..a90ba51 --- /dev/null +++ b/src/wit/pumpkin/plugin/java_packets/imports.d @@ -0,0 +1,13 @@ +/++ + ++/ +module wit.pumpkin.plugin.java_packets.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.java_packets.common; + +static import wit.pumpkin.plugin.uuid.imports; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); diff --git a/src/wit/pumpkin/plugin/logging/common.d b/src/wit/pumpkin/plugin/logging/common.d new file mode 100644 index 0000000..2cc75a0 --- /dev/null +++ b/src/wit/pumpkin/plugin/logging/common.d @@ -0,0 +1,40 @@ +/++ + ++/ +module wit.pumpkin.plugin.logging.common; + + +import wit.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +enum Level : ubyte { + /++ + + +/ + trace, + + /++ + + +/ + debug_, + + /++ + + +/ + info, + + /++ + + +/ + warn, + + /++ + + +/ + error, +} \ No newline at end of file diff --git a/src/wit/pumpkin/plugin/logging/imports.d b/src/wit/pumpkin/plugin/logging/imports.d new file mode 100644 index 0000000..d15ccbe --- /dev/null +++ b/src/wit/pumpkin/plugin/logging/imports.d @@ -0,0 +1,34 @@ +/++ + ++/ +module wit.pumpkin.plugin.logging.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.logging.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ +log any general purpose message ++/ +void log(Level level, in WitString message) @trusted nothrow { + __import_log(cast(uint)(level), cast(void*)(message.ptr), message.length); +} +/// ditto +@wasmImport!("pumpkin:plugin/logging@0.1.0", "log") +pragma(mangle, "__wit_import_pumpkin:plugin__logging@0.1.0__log") +private extern(C) void __import_log(uint, void*, size_t) nothrow; + +/++ +This function is meant to be used by the tracing crate. ++/ +void logTracing(in WitList!(ubyte) event) @trusted nothrow { + __import_logTracing(cast(void*)(event.ptr), event.length); +} +/// ditto +@wasmImport!("pumpkin:plugin/logging@0.1.0", "log-tracing") +pragma(mangle, "__wit_import_pumpkin:plugin__logging@0.1.0__log_tracing") +private extern(C) void __import_logTracing(void*, size_t) nothrow; diff --git a/src/wit/pumpkin/plugin/metadata/common.d b/src/wit/pumpkin/plugin/metadata/common.d new file mode 100644 index 0000000..2f5ee81 --- /dev/null +++ b/src/wit/pumpkin/plugin/metadata/common.d @@ -0,0 +1,68 @@ +/++ +Plugin metadata describing the plugin and its compatibility. ++/ +module wit.pumpkin.plugin.metadata.common; + + +import wit.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +struct PluginMetadata { + /++ + Name of the plugin. + +/ + WitString name; + + /++ + Plugin version (semver). + +/ + WitString version_; + + /++ + Plugin authors. + +/ + WitList!(WitString) authors; + + /++ + Short description of the plugin. + +/ + WitString description; + + /++ + Plugin dependencies. + +/ + WitList!(WitString) dependencies; + + /++ + Permissions requested by the plugin. + +/ + WitList!(WitString) permissions; + + void witFree() @nogc nothrow { + name.witFree; + version_.witFree; + authors.witFree; + description.witFree; + dependencies.witFree; + permissions.witFree; + } + + void witDrop() @nogc nothrow { + } + + PluginMetadata witClone() const @nogc nothrow { + PluginMetadata clone = void; + clone.name = this.name.witClone; + clone.version_ = this.version_.witClone; + clone.authors = this.authors.witClone; + clone.description = this.description.witClone; + clone.dependencies = this.dependencies.witClone; + clone.permissions = this.permissions.witClone; + return clone; + } +} diff --git a/src/wit/pumpkin/plugin/metadata/exports.d b/src/wit/pumpkin/plugin/metadata/exports.d new file mode 100644 index 0000000..c6ba48b --- /dev/null +++ b/src/wit/pumpkin/plugin/metadata/exports.d @@ -0,0 +1,124 @@ +/++ +Plugin metadata describing the plugin and its compatibility. ++/ +module wit.pumpkin.plugin.metadata.exports; + + +import wit.common; + +public import wit.pumpkin.plugin.metadata.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +package(wit) template Exports(Impl...) { + + /++ + + +/ + alias getMetadata_Sig = PluginMetadata function(); + /// ditto + alias getMetadata_Impl = findWitExportFunc!("pumpkin:plugin/metadata@0.1.0", "get-metadata", getMetadata_Sig, Impl); + /// ditto + @wasmExport!("pumpkin:plugin/metadata@0.1.0#get-metadata") + pragma(mangle, "__wit_export_pumpkin:plugin__metadata@0.1.0::get_metadata") + private extern(C) void* __export_getMetadata() { + alias _retArea = _exportsRetArea; + auto _ret = getMetadata_Impl(); + *cast(size_t*)(_retArea.ptr + size_t.sizeof) = cast(size_t)(_ret.name.length); + *cast(void**)(_retArea.ptr + 0) = cast(void*)(cast(void*)(_ret.name.ptr)); + *cast(size_t*)(_retArea.ptr + (3*size_t.sizeof)) = cast(size_t)(_ret.version_.length); + *cast(void**)(_retArea.ptr + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_ret.version_.ptr)); + auto _listSrc1 = _ret.authors; + auto _list1 = _listSrc1.length ? wit.common.malloc(_listSrc1.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc1.length || _list1); + foreach (_elem0_idx, ref _elem0; _listSrc1) { + auto _base0 = _list1 + _elem0_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base0 + size_t.sizeof) = cast(size_t)(_elem0.length); + *cast(void**)(_base0 + 0) = cast(void*)(cast(void*)(_elem0.ptr)); + + } + if (_listSrc1.length) wit.common.free(_listSrc1.ptr); + *cast(size_t*)(_retArea.ptr + (5*size_t.sizeof)) = cast(size_t)(_ret.authors.length); + *cast(void**)(_retArea.ptr + (4*size_t.sizeof)) = cast(void*)(_list1); + *cast(size_t*)(_retArea.ptr + (7*size_t.sizeof)) = cast(size_t)(_ret.description.length); + *cast(void**)(_retArea.ptr + (6*size_t.sizeof)) = cast(void*)(cast(void*)(_ret.description.ptr)); + auto _listSrc3 = _ret.dependencies; + auto _list3 = _listSrc3.length ? wit.common.malloc(_listSrc3.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc3.length || _list3); + foreach (_elem2_idx, ref _elem2; _listSrc3) { + auto _base2 = _list3 + _elem2_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base2 + size_t.sizeof) = cast(size_t)(_elem2.length); + *cast(void**)(_base2 + 0) = cast(void*)(cast(void*)(_elem2.ptr)); + + } + if (_listSrc3.length) wit.common.free(_listSrc3.ptr); + *cast(size_t*)(_retArea.ptr + (9*size_t.sizeof)) = cast(size_t)(_ret.dependencies.length); + *cast(void**)(_retArea.ptr + (8*size_t.sizeof)) = cast(void*)(_list3); + auto _listSrc5 = _ret.permissions; + auto _list5 = _listSrc5.length ? wit.common.malloc(_listSrc5.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5.length || _list5); + foreach (_elem4_idx, ref _elem4; _listSrc5) { + auto _base4 = _list5 + _elem4_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base4 + size_t.sizeof) = cast(size_t)(_elem4.length); + *cast(void**)(_base4 + 0) = cast(void*)(cast(void*)(_elem4.ptr)); + + } + if (_listSrc5.length) wit.common.free(_listSrc5.ptr); + *cast(size_t*)(_retArea.ptr + (11*size_t.sizeof)) = cast(size_t)(_ret.permissions.length); + *cast(void**)(_retArea.ptr + (10*size_t.sizeof)) = cast(void*)(_list5); + return _retArea.ptr; + } + @wasmExport!("cabi_post_pumpkin:plugin/metadata@0.1.0#get-metadata") + pragma(mangle, "__wit_cabi_post_pumpkin:plugin__metadata@0.1.0::get_metadata") + private extern(C) void __cabi_post_getMetadata(void* arg0) { + if (*(cast(size_t*)(arg0 + size_t.sizeof)) > 0) { + free(*(cast(void**)(arg0 + 0))); + } + if (*(cast(size_t*)(arg0 + (3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (2*size_t.sizeof)))); + } + auto _listSrcPtr1 = *(cast(void**)(arg0 + (4*size_t.sizeof))); + auto _listLen1 = *(cast(size_t*)(arg0 + (5*size_t.sizeof))); + foreach (_elem0_idx; 0.._listLen1) { + const auto _base0 = _listSrcPtr1 + _elem0_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base0 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base0 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (5*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (4*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (7*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (6*size_t.sizeof)))); + } + auto _listSrcPtr3 = *(cast(void**)(arg0 + (8*size_t.sizeof))); + auto _listLen3 = *(cast(size_t*)(arg0 + (9*size_t.sizeof))); + foreach (_elem2_idx; 0.._listLen3) { + const auto _base2 = _listSrcPtr3 + _elem2_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base2 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base2 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (9*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8*size_t.sizeof)))); + } + auto _listSrcPtr5 = *(cast(void**)(arg0 + (10*size_t.sizeof))); + auto _listLen5 = *(cast(size_t*)(arg0 + (11*size_t.sizeof))); + foreach (_elem4_idx; 0.._listLen5) { + const auto _base4 = _listSrcPtr5 + _elem4_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base4 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base4 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (11*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (10*size_t.sizeof)))); + } + } + + align(size_t.sizeof) private void[(12*size_t.sizeof)] _exportsRetArea; +} + diff --git a/src/wit/pumpkin/plugin/particles/common.d b/src/wit/pumpkin/plugin/particles/common.d new file mode 100644 index 0000000..d707934 --- /dev/null +++ b/src/wit/pumpkin/plugin/particles/common.d @@ -0,0 +1,640 @@ +/++ + ++/ +module wit.pumpkin.plugin.particles.common; + + +import wit.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +enum Particle : ubyte { + /++ + + +/ + angryVillager, + + /++ + + +/ + block, + + /++ + + +/ + blockMarker, + + /++ + + +/ + bubble, + + /++ + + +/ + sulfurBubbles, + + /++ + + +/ + noxiousGas, + + /++ + + +/ + noxiousGasCloud, + + /++ + + +/ + geyser, + + /++ + + +/ + geyserBase, + + /++ + + +/ + geyserPoof, + + /++ + + +/ + geyserPlume, + + /++ + + +/ + cloud, + + /++ + + +/ + copperFireFlame, + + /++ + + +/ + crit, + + /++ + + +/ + damageIndicator, + + /++ + + +/ + dragonBreath, + + /++ + + +/ + drippingLava, + + /++ + + +/ + fallingLava, + + /++ + + +/ + landingLava, + + /++ + + +/ + drippingWater, + + /++ + + +/ + fallingWater, + + /++ + + +/ + dust, + + /++ + + +/ + dustColorTransition, + + /++ + + +/ + effect, + + /++ + + +/ + elderGuardian, + + /++ + + +/ + enchantedHit, + + /++ + + +/ + enchant, + + /++ + + +/ + endRod, + + /++ + + +/ + entityEffect, + + /++ + + +/ + explosionEmitter, + + /++ + + +/ + explosion, + + /++ + + +/ + gust, + + /++ + + +/ + smallGust, + + /++ + + +/ + gustEmitterLarge, + + /++ + + +/ + gustEmitterSmall, + + /++ + + +/ + sonicBoom, + + /++ + + +/ + fallingDust, + + /++ + + +/ + firework, + + /++ + + +/ + fishing, + + /++ + + +/ + flame, + + /++ + + +/ + infested, + + /++ + + +/ + cherryLeaves, + + /++ + + +/ + paleOakLeaves, + + /++ + + +/ + tintedLeaves, + + /++ + + +/ + sculkSoul, + + /++ + + +/ + sculkCharge, + + /++ + + +/ + sculkChargePop, + + /++ + + +/ + soulFireFlame, + + /++ + + +/ + soul, + + /++ + + +/ + flash, + + /++ + + +/ + happyVillager, + + /++ + + +/ + composter, + + /++ + + +/ + heart, + + /++ + + +/ + instantEffect, + + /++ + + +/ + item, + + /++ + + +/ + vibration, + + /++ + + +/ + trail, + + /++ + + +/ + pauseMobGrowth, + + /++ + + +/ + resetMobGrowth, + + /++ + + +/ + itemSlime, + + /++ + + +/ + itemCobweb, + + /++ + + +/ + itemSnowball, + + /++ + + +/ + largeSmoke, + + /++ + + +/ + lava, + + /++ + + +/ + mycelium, + + /++ + + +/ + note, + + /++ + + +/ + poof, + + /++ + + +/ + portal, + + /++ + + +/ + rain, + + /++ + + +/ + smoke, + + /++ + + +/ + whiteSmoke, + + /++ + + +/ + sneeze, + + /++ + + +/ + spit, + + /++ + + +/ + squidInk, + + /++ + + +/ + sweepAttack, + + /++ + + +/ + totemOfUndying, + + /++ + + +/ + underwater, + + /++ + + +/ + splash, + + /++ + + +/ + witch, + + /++ + + +/ + bubblePop, + + /++ + + +/ + currentDown, + + /++ + + +/ + bubbleColumnUp, + + /++ + + +/ + nautilus, + + /++ + + +/ + dolphin, + + /++ + + +/ + campfireCosySmoke, + + /++ + + +/ + campfireSignalSmoke, + + /++ + + +/ + drippingHoney, + + /++ + + +/ + fallingHoney, + + /++ + + +/ + landingHoney, + + /++ + + +/ + fallingNectar, + + /++ + + +/ + fallingSporeBlossom, + + /++ + + +/ + ash, + + /++ + + +/ + crimsonSpore, + + /++ + + +/ + warpedSpore, + + /++ + + +/ + sporeBlossomAir, + + /++ + + +/ + drippingObsidianTear, + + /++ + + +/ + fallingObsidianTear, + + /++ + + +/ + landingObsidianTear, + + /++ + + +/ + reversePortal, + + /++ + + +/ + whiteAsh, + + /++ + + +/ + smallFlame, + + /++ + + +/ + snowflake, + + /++ + + +/ + drippingDripstoneLava, + + /++ + + +/ + fallingDripstoneLava, + + /++ + + +/ + drippingDripstoneWater, + + /++ + + +/ + fallingDripstoneWater, + + /++ + + +/ + glowSquidInk, + + /++ + + +/ + glow, + + /++ + + +/ + waxOn, + + /++ + + +/ + waxOff, + + /++ + + +/ + electricSpark, + + /++ + + +/ + scrape, + + /++ + + +/ + shriek, + + /++ + + +/ + eggCrack, + + /++ + + +/ + dustPlume, + + /++ + + +/ + trialSpawnerDetection, + + /++ + + +/ + trialSpawnerDetectionOminous, + + /++ + + +/ + vaultConnection, + + /++ + + +/ + dustPillar, + + /++ + + +/ + ominousSpawning, + + /++ + + +/ + raidOmen, + + /++ + + +/ + trialOmen, + + /++ + + +/ + blockCrumble, + + /++ + + +/ + firefly, + + /++ + + +/ + sulfurCubeGoo, +} \ No newline at end of file diff --git a/src/wit/pumpkin/plugin/particles/imports.d b/src/wit/pumpkin/plugin/particles/imports.d new file mode 100644 index 0000000..27f0386 --- /dev/null +++ b/src/wit/pumpkin/plugin/particles/imports.d @@ -0,0 +1,12 @@ +/++ + ++/ +module wit.pumpkin.plugin.particles.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.particles.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); diff --git a/src/wit/pumpkin/plugin/permission/common.d b/src/wit/pumpkin/plugin/permission/common.d new file mode 100644 index 0000000..c301704 --- /dev/null +++ b/src/wit/pumpkin/plugin/permission/common.d @@ -0,0 +1,186 @@ +/++ + ++/ +module wit.pumpkin.plugin.permission.common; + + +import wit.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ +Represents the player's permission level + +Permission levels determine the player's access to commands and server operations. +Each numeric level corresponds to a specific role: +- `Zero`: `normal`: Player can use basic commands. +- `One`: `moderator`: Player can bypass spawn protection. +- `Two`: `gamemaster`: Player or executor can use more commands and player can use command blocks. +- `Three`: `admin`: Player or executor can use commands related to multiplayer management. +- `Four`: `owner`: Player or executor can use all of the commands, including commands related to server management. ++/ +enum PermissionLevel : ubyte { + /++ + + +/ + zero, + + /++ + + +/ + one, + + /++ + + +/ + two, + + /++ + + +/ + three, + + /++ + + +/ + four, +} +/++ +Describes the default behavior for permissions ++/ +struct PermissionDefault { + mixin WitVariant!( + void, // deny + void, // allow + PermissionLevel, // op + ); + +public: + enum Tag : ubyte { + /++ + Permission is not granted by default + +/ + deny, + + /++ + Permission is granted by default + +/ + allow, + + /++ + Permission is granted by default to operators + +/ + op, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + Permission is not granted by default + +/ + alias deny = _create!(Tag.deny); + /// ditto + pragma(inline, true) bool isDeny() const => _tag == Tag.deny; + + /++ + Permission is granted by default + +/ + alias allow = _create!(Tag.allow); + /// ditto + pragma(inline, true) bool isAllow() const => _tag == Tag.allow; + + /++ + Permission is granted by default to operators + +/ + alias op = _create!(Tag.op); + /// ditto + pragma(inline, true) bool isOp() const => _tag == Tag.op; + ///ditto + alias getOp = _get!(Tag.op); + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + PermissionDefault witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.deny: return _create!(Tag.deny); break; + case Tag.allow: return _create!(Tag.allow); break; + case Tag.op: return _create!(Tag.op)(this._get!(Tag.op).witClone); break; + } + } +} + +/++ +A child permission entry ++/ +struct PermissionChild { + /++ + + +/ + WitString node; + + /++ + + +/ + bool value; + + void witFree() @nogc nothrow { + node.witFree; + } + + void witDrop() @nogc nothrow { + } + + PermissionChild witClone() const @nogc nothrow { + PermissionChild clone = void; + clone.node = this.node.witClone; + clone.value = this.value.witClone; + return clone; + } +} + +/++ +Defines a permission node in the system ++/ +struct Permission { + /++ + The full node name (e.g., "minecraft:command.gamemode") + +/ + WitString node; + + /++ + Description of what this permission does + +/ + WitString description; + + /++ + The default value of this permission + +/ + PermissionDefault default_; + + /++ + Children nodes that are affected by this permission + +/ + WitList!(PermissionChild) children; + + void witFree() @nogc nothrow { + node.witFree; + description.witFree; + children.witFree; + } + + void witDrop() @nogc nothrow { + } + + Permission witClone() const @nogc nothrow { + Permission clone = void; + clone.node = this.node.witClone; + clone.description = this.description.witClone; + clone.default_ = this.default_.witClone; + clone.children = this.children.witClone; + return clone; + } +} diff --git a/src/wit/pumpkin/plugin/permission/imports.d b/src/wit/pumpkin/plugin/permission/imports.d new file mode 100644 index 0000000..deef582 --- /dev/null +++ b/src/wit/pumpkin/plugin/permission/imports.d @@ -0,0 +1,12 @@ +/++ + ++/ +module wit.pumpkin.plugin.permission.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.permission.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); diff --git a/src/wit/pumpkin/plugin/player/common.d b/src/wit/pumpkin/plugin/player/common.d new file mode 100644 index 0000000..286b1aa --- /dev/null +++ b/src/wit/pumpkin/plugin/player/common.d @@ -0,0 +1,2813 @@ +/++ +Represents a player connected to the Minecraft server. ++/ +module wit.pumpkin.plugin.player.common; + + +import wit.common; + +static import wit.pumpkin.plugin.common.common; +static import wit.pumpkin.plugin.damage_types.common; +static import wit.pumpkin.plugin.entity_statuses.common; +static import wit.pumpkin.plugin.particles.common; +static import wit.pumpkin.plugin.permission.common; +static import wit.pumpkin.plugin.sounds.common; +static import wit.pumpkin.plugin.statistics.common; +static import wit.pumpkin.plugin.status_effect.common; +static import wit.pumpkin.plugin.text.common; +static import wit.pumpkin.plugin.advancement.common; +static import wit.pumpkin.plugin.forms.common; +static import wit.pumpkin.plugin.item_stack.common; +static import wit.pumpkin.plugin.inventory.common; +static import wit.pumpkin.plugin.gui.common; +static import wit.pumpkin.plugin.java_dialogs.common; +static import wit.pumpkin.plugin.scoreboard.common; +static import wit.pumpkin.plugin.uuid.common; +static import wit.pumpkin.plugin.bedrock_packets.common; +static import wit.pumpkin.plugin.java_packets.common; +static import wit.pumpkin.plugin.world.common; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias Hand = wit.pumpkin.plugin.common.common.Hand; + +/++ + ++/ +alias Position = wit.pumpkin.plugin.common.common.Position; + +/++ + ++/ +alias GameMode = wit.pumpkin.plugin.common.common.GameMode; + +/++ + ++/ +alias BlockPos = wit.pumpkin.plugin.common.common.BlockPos; + +/++ + ++/ +alias RayTraceBlockResult = wit.pumpkin.plugin.world.common.RayTraceBlockResult; + +/++ + ++/ +alias PermissionLevel = wit.pumpkin.plugin.permission.common.PermissionLevel; + +/++ + ++/ +alias JavaPacket = wit.pumpkin.plugin.java_packets.common.ClientboundPacket; + +/++ + ++/ +alias BedrockPacket = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket; + +/++ + ++/ +alias Uuid = wit.pumpkin.plugin.uuid.common.Uuid; + +/++ + ++/ +alias StatusEffectType = wit.pumpkin.plugin.status_effect.common.StatusEffectType; + +/++ + ++/ +alias StatusEffectInstance = wit.pumpkin.plugin.status_effect.common.StatusEffectInstance; + +/++ + ++/ +alias AdvancementProgress = wit.pumpkin.plugin.advancement.common.AdvancementProgress; + +/++ + ++/ +alias DamageType = wit.pumpkin.plugin.damage_types.common.DamageType; + +/++ + ++/ +alias StatisticCategory = wit.pumpkin.plugin.statistics.common.StatisticCategory; + +/++ + ++/ +alias CustomStatistic = wit.pumpkin.plugin.statistics.common.CustomStatistic; + +/++ + ++/ +alias Sound = wit.pumpkin.plugin.sounds.common.Sound; + +/++ + ++/ +alias SoundCategory = wit.pumpkin.plugin.sounds.common.SoundCategory; + +/++ + ++/ +alias Particle = wit.pumpkin.plugin.particles.common.Particle; + +/++ + ++/ +alias EntityStatus = wit.pumpkin.plugin.entity_statuses.common.EntityStatus; + +/++ +Represents per-player weather condition overrides. ++/ +enum PlayerWeather : ubyte { + /++ + + +/ + clear, + + /++ + + +/ + downfall, +} +/++ +Types of projectiles that can be launched by a player. ++/ +enum ProjectileType : ubyte { + /++ + + +/ + arrow, + + /++ + + +/ + snowball, + + /++ + + +/ + egg, + + /++ + + +/ + enderPearl, + + /++ + + +/ + splashPotion, + + /++ + + +/ + fireball, + + /++ + + +/ + smallFireball, + + /++ + + +/ + trident, + + /++ + + +/ + windCharge, +} +/++ +Types of clientbound game events. ++/ +enum ClientGameEvent : ubyte { + /++ + + +/ + noRespawnBlockAvailable, + + /++ + + +/ + beginRaining, + + /++ + + +/ + endRaining, + + /++ + + +/ + changeGameMode, + + /++ + + +/ + winGame, + + /++ + + +/ + demoEvent, + + /++ + + +/ + arrowHitPlayer, + + /++ + + +/ + rainLevelChange, + + /++ + + +/ + thunderLevelChange, + + /++ + + +/ + playPufferfishStringSound, + + /++ + + +/ + playElderGuardianMobAppearance, + + /++ + + +/ + enabledRespawnScreen, + + /++ + + +/ + limitedCrafting, + + /++ + + +/ + startWaitingChunks, +} +/++ +Built-in known server link types displayed in the client Escape pause menu. ++/ +enum KnownServerLink : ubyte { + /++ + + +/ + bugReport, + + /++ + + +/ + communityGuidelines, + + /++ + + +/ + support, + + /++ + + +/ + status, + + /++ + + +/ + feedback, + + /++ + + +/ + community, + + /++ + + +/ + website, + + /++ + + +/ + forums, + + /++ + + +/ + news, + + /++ + + +/ + announcements, +} +/++ +Various abilities a player can have. ++/ +struct PlayerAbilities { + /++ + Whether the player is invulnerable to damage. + +/ + bool invulnerable; + + /++ + Whether the player is currently flying. + +/ + bool flying; + + /++ + Whether the player is allowed to fly. + +/ + bool allowFlying; + + /++ + Whether the player is in creative mode. + +/ + bool creative; + + /++ + Whether the player can modify the world. + +/ + bool allowModifyWorld; + + /++ + The speed at which the player flies. + +/ + float flySpeed; + + /++ + The speed at which the player walks. + +/ + float walkSpeed; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + PlayerAbilities witClone() const @nogc nothrow { + PlayerAbilities clone = void; + clone.invulnerable = this.invulnerable.witClone; + clone.flying = this.flying.witClone; + clone.allowFlying = this.allowFlying.witClone; + clone.creative = this.creative.witClone; + clone.allowModifyWorld = this.allowModifyWorld.witClone; + clone.flySpeed = this.flySpeed.witClone; + clone.walkSpeed = this.walkSpeed.witClone; + return clone; + } +} + +/++ +Represents a player's skin textures and metadata. ++/ +struct PlayerSkin { + /++ + The base64-encoded texture data (usually JSON containing skin/cape URLs). + +/ + WitString value; + + /++ + The optional signature for the texture data. + +/ + Option!(WitString) signature; + + void witFree() @nogc nothrow { + value.witFree; + signature.witFree; + } + + void witDrop() @nogc nothrow { + } + + PlayerSkin witClone() const @nogc nothrow { + PlayerSkin clone = void; + clone.value = this.value.witClone; + clone.signature = this.signature.witClone; + return clone; + } +} + +/++ +Represents which skin parts are visible. ++/ +struct SkinParts { + mixin WitFlags!ubyte; + + /++ + + +/ + enum cape = SkinParts[0]; + + /++ + + +/ + enum jacket = SkinParts[1]; + + /++ + + +/ + enum leftSleeve = SkinParts[2]; + + /++ + + +/ + enum rightSleeve = SkinParts[3]; + + /++ + + +/ + enum leftPantsLeg = SkinParts[4]; + + /++ + + +/ + enum rightPantsLeg = SkinParts[5]; + + /++ + + +/ + enum hat = SkinParts[6]; +} + +/++ +Represents the various abilities a Bedrock Edition player can have. ++/ +enum BedrockAbility : ubyte { + /++ + Whether the player can build. + +/ + build, + + /++ + Whether the player can mine blocks. + +/ + mine, + + /++ + Whether the player can use doors and switches. + +/ + doorsAndSwitches, + + /++ + Whether the player can open containers. + +/ + openContainers, + + /++ + Whether the player can attack other players. + +/ + attackPlayers, + + /++ + Whether the player can attack mobs. + +/ + attackMobs, + + /++ + Whether the player can use operator commands. + +/ + operatorCommands, + + /++ + Whether the player can teleport. + +/ + teleport, + + /++ + Whether the player is invulnerable. + +/ + invulnerable, + + /++ + Whether the player is currently flying. + +/ + flying, + + /++ + Whether the player is allowed to fly. + +/ + mayFly, + + /++ + Whether the player has instant build (creative). + +/ + instabuild, + + /++ + Whether the player can use lightning-related abilities. + +/ + lightning, + + /++ + The speed at which the player flies. + +/ + flySpeed, + + /++ + The speed at which the player walks. + +/ + walkSpeed, + + /++ + Whether the player is muted. + +/ + muted, + + /++ + Whether the player is a world builder. + +/ + worldBuilder, + + /++ + Whether the player has no-clip enabled. + +/ + noClip, + + /++ + Whether the player is a privileged builder. + +/ + privilegedBuilder, + + /++ + The speed at which the player flies vertically. + +/ + verticalFlySpeed, +} +/++ +Represents the various status flags a Bedrock Edition entity can have. +These flags control client-side rendering and behavior. ++/ +enum BedrockStatusFlag : ubyte { + /++ + Whether the entity is currently on fire. + +/ + onFire, + + /++ + Whether the entity is sneaking. + +/ + sneaking, + + /++ + Whether the entity is riding another entity. + +/ + riding, + + /++ + Whether the entity is sprinting. + +/ + sprinting, + + /++ + Whether the entity is using an item (e.g., eating, blocking). + +/ + usingItem, + + /++ + Whether the entity is invisible. + +/ + invisible, + + /++ + Whether the entity is tempted by an item. + +/ + tempted, + + /++ + Whether the entity is in love (breeding). + +/ + inLove, + + /++ + Whether the entity is saddled. + +/ + saddled, + + /++ + Whether the entity is powered (e.g., charged creeper). + +/ + powered, + + /++ + Whether the entity is ignited. + +/ + ignited, + + /++ + Whether the entity is a baby. + +/ + baby, + + /++ + Whether the entity is currently converting to another type. + +/ + converting, + + /++ + Whether the entity is in a critical state. + +/ + critical, + + /++ + Whether to show the entity's name tag. + +/ + showName, + + /++ + Whether to always show the entity's name tag. + +/ + alwaysShowName, + + /++ + Whether the entity has no AI. + +/ + noAi, + + /++ + Whether the entity is silent. + +/ + silent, + + /++ + Whether the entity is climbing a wall. + +/ + wallClimbing, + + /++ + Whether the entity is climbing. + +/ + climb, + + /++ + Whether the entity is swimming. + +/ + swim, + + /++ + Whether the entity is flying. + +/ + fly, + + /++ + Whether the entity is walking. + +/ + walk, + + /++ + Whether the entity is resting. + +/ + resting, + + /++ + Whether the entity is sitting. + +/ + sitting, + + /++ + Whether the entity is angry. + +/ + angry, + + /++ + Whether the entity is interested. + +/ + interested, + + /++ + Whether the entity is charged. + +/ + charged, + + /++ + Whether the entity is tamed. + +/ + tamed, + + /++ + Whether the entity is orphaned. + +/ + orphaned, + + /++ + Whether the entity is leashed. + +/ + leashed, + + /++ + Whether the entity is sheared. + +/ + sheared, + + /++ + Whether the entity is gliding (elytra). + +/ + gliding, + + /++ + Whether the entity is an elder (e.g., elder guardian). + +/ + elder, + + /++ + Whether the entity is moving. + +/ + moving, + + /++ + Whether the entity is breathing. + +/ + breathing, + + /++ + Whether the entity has a chest (e.g., donkey). + +/ + chested, + + /++ + Whether the entity is stackable. + +/ + stackable, + + /++ + Whether to show the bottom of the entity. + +/ + showBottom, + + /++ + Whether the entity is standing. + +/ + standing, + + /++ + Whether the entity is shaking. + +/ + shaking, + + /++ + Whether the entity is idling. + +/ + idling, + + /++ + Whether the entity is casting (e.g., evoker). + +/ + casting, + + /++ + Whether the entity is charging an attack. + +/ + charging, + + /++ + Whether the entity is controlled by a keyboard. + +/ + keyboardControlled, + + /++ + Whether the entity is performing a power jump. + +/ + powerJump, + + /++ + Whether the entity is dashing. + +/ + dash, + + /++ + Whether the entity is lingering. + +/ + lingering, + + /++ + Whether the entity has collision. + +/ + hasCollision, + + /++ + Whether the entity has gravity. + +/ + hasGravity, + + /++ + Whether the entity is immune to fire. + +/ + fireImmune, + + /++ + Whether the entity is dancing. + +/ + dancing, + + /++ + Whether the entity is enchanted. + +/ + enchanted, + + /++ + Whether a trident will return to the entity. + +/ + returnTrident, + + /++ + Whether the container is private. + +/ + containerPrivate, + + /++ + Whether the entity is transforming. + +/ + transforming, + + /++ + Whether the entity damages nearby mobs. + +/ + damageNearbyMobs, + + /++ + Whether the entity is swimming. + +/ + swimming, + + /++ + Whether the entity has been bribed. + +/ + bribed, + + /++ + Whether the entity is pregnant. + +/ + pregnant, + + /++ + Whether the entity is laying an egg. + +/ + layingEgg, + + /++ + Whether a passenger can pick up the entity. + +/ + passengerCanPick, + + /++ + Whether the entity is transitioning to sitting. + +/ + transitionSitting, + + /++ + Whether the entity is eating. + +/ + eating, + + /++ + Whether the entity is laying down. + +/ + layingDown, + + /++ + Whether the entity is sneezing. + +/ + sneezing, + + /++ + Whether the entity is trusting. + +/ + trusting, + + /++ + Whether the entity is rolling. + +/ + rolling, + + /++ + Whether the entity is scared. + +/ + scared, + + /++ + Whether the entity is in scaffolding. + +/ + inScaffolding, + + /++ + Whether the entity is over scaffolding. + +/ + overScaffolding, + + /++ + Whether the entity is descending through a block. + +/ + descendThroughBlock, + + /++ + Whether the entity is blocking. + +/ + blocking, + + /++ + Whether the entity is transitioning to blocking. + +/ + transitionBlocking, + + /++ + Whether the entity is blocked using a shield. + +/ + blockedUsingShield, + + /++ + Whether the entity is blocked using a damaged shield. + +/ + blockedUsingDamagedShield, + + /++ + Whether the entity is sleeping. + +/ + sleeping, + + /++ + Whether the entity wants to wake up. + +/ + wantsToWake, + + /++ + Whether the entity shows interest in trading. + +/ + tradeInterest, + + /++ + Whether the entity can break doors. + +/ + doorBreaker, + + /++ + Whether the entity is breaking an obstruction. + +/ + breakingObstruction, + + /++ + Whether the entity can open doors. + +/ + doorOpener, + + /++ + Whether the entity is a captain (raid). + +/ + captain, + + /++ + Whether the entity is stunned. + +/ + stunned, + + /++ + Whether the entity is roaring. + +/ + roaring, + + /++ + Whether the entity has a delayed attack. + +/ + delayedAttack, + + /++ + Whether the entity is avoiding mobs. + +/ + avoidingMobs, + + /++ + Whether the entity is avoiding a block. + +/ + avoidingBlock, + + /++ + Whether the entity is facing a target for a ranged attack. + +/ + facingTargetToRangeAttack, + + /++ + Whether the entity is hidden when invisible. + +/ + hiddenWhenInvisible, + + /++ + Whether the entity is in a UI. + +/ + inUi, + + /++ + Whether the entity is stalking. + +/ + stalking, + + /++ + Whether the entity is emoting. + +/ + emoting, + + /++ + Whether the entity is celebrating. + +/ + celebrating, + + /++ + Whether the entity is admiring (piglin). + +/ + admiring, + + /++ + Whether the entity is celebrating a special event. + +/ + celebratingSpecial, + + /++ + Whether the entity is out of control. + +/ + outOfControl, + + /++ + Whether the entity is performing a ram attack. + +/ + ramAttack, + + /++ + Whether the entity is playing dead. + +/ + playingDead, + + /++ + Whether the entity is in an ascending block. + +/ + inAscendingBlock, + + /++ + Whether the entity is over a descending block. + +/ + overDescendingBlock, + + /++ + Whether the entity is croaking (frog). + +/ + croaking, + + /++ + Whether the entity is digesting a mob. + +/ + digestMob, + + /++ + Whether the entity has a jump goal. + +/ + jumpGoal, + + /++ + Whether the entity is emerging. + +/ + emerging, + + /++ + Whether the entity is sniffing. + +/ + sniffing, + + /++ + Whether the entity is digging. + +/ + digging, + + /++ + Whether the entity is performing a sonic boom. + +/ + sonicBoom, + + /++ + Whether the entity has a dash timeout. + +/ + hasDashTimeout, + + /++ + Whether the entity is pushed towards the closest space. + +/ + pushTowardsClosestSpace, + + /++ + Whether the entity is scenting. + +/ + scenting, + + /++ + Whether the entity is rising. + +/ + rising, + + /++ + Whether the entity is feeling happy. + +/ + feelingHappy, + + /++ + Whether the entity is searching. + +/ + searching, + + /++ + Whether the entity is crawling. + +/ + crawling, + + /++ + Whether the entity's body rotation is blocked. + +/ + bodyRotationBlocked, + + /++ + Whether the entity is rendered when invisible. + +/ + renderWhenInvisible, + + /++ + Whether the entity's body rotation is axis-aligned. + +/ + bodyRotationAxisAligned, + + /++ + Whether the entity is collidable. + +/ + collidable, + + /++ + Whether the entity is air-controlled via WASD. + +/ + wasdAirControlled, + + /++ + Whether only the server can authorize a dismount. + +/ + doesServerAuthOnlyDismount, + + /++ + Whether the body rotation always follows the head. + +/ + bodyRotationAlwaysFollowsHead, + + /++ + Whether the entity can use vertical movement actions. + +/ + canUseVerticalMovementAction, + + /++ + Whether rotation is locked to the vehicle. + +/ + rotationLockedToVehicle, +} +/++ +Represents a specific version of the Minecraft Java Edition protocol. ++/ +enum JavaMinecraftVersion : ubyte { + /++ + + +/ + v172, + + /++ + + +/ + v176, + + /++ + + +/ + v18, + + /++ + + +/ + v19, + + /++ + + +/ + v191, + + /++ + + +/ + v192, + + /++ + + +/ + v193, + + /++ + + +/ + v110, + + /++ + + +/ + v111, + + /++ + + +/ + v1111, + + /++ + + +/ + v112, + + /++ + + +/ + v1121, + + /++ + + +/ + v1122, + + /++ + + +/ + v113, + + /++ + + +/ + v1131, + + /++ + + +/ + v1132, + + /++ + + +/ + v114, + + /++ + + +/ + v1141, + + /++ + + +/ + v1142, + + /++ + + +/ + v1143, + + /++ + + +/ + v1144, + + /++ + + +/ + v115, + + /++ + + +/ + v1151, + + /++ + + +/ + v1152, + + /++ + + +/ + v116, + + /++ + + +/ + v1161, + + /++ + + +/ + v1162, + + /++ + + +/ + v1163, + + /++ + + +/ + v1164, + + /++ + + +/ + v117, + + /++ + + +/ + v1171, + + /++ + + +/ + v118, + + /++ + + +/ + v1182, + + /++ + + +/ + v119, + + /++ + + +/ + v1191, + + /++ + + +/ + v1193, + + /++ + + +/ + v1194, + + /++ + + +/ + v120, + + /++ + + +/ + v1202, + + /++ + + +/ + v1203, + + /++ + + +/ + v1205, + + /++ + + +/ + v121, + + /++ + + +/ + v1212, + + /++ + + +/ + v1214, + + /++ + + +/ + v1215, + + /++ + + +/ + v1216, + + /++ + + +/ + v1217, + + /++ + + +/ + v1219, + + /++ + + +/ + v12111, + + /++ + + +/ + v261, + + /++ + + +/ + v262, + + /++ + + +/ + unknown, +} +/++ +Represents a specific version of the Minecraft Bedrock Edition protocol. ++/ +enum BedrockMinecraftVersion : ubyte { + /++ + + +/ + v121, + + /++ + + +/ + v12630, + + /++ + + +/ + unknown, +} +/++ +The chat visibility settings for a player. ++/ +enum ChatMode : ubyte { + /++ + Chat is fully enabled. + +/ + enabled, + + /++ + Only system messages and commands are shown. + +/ + commandsOnly, + + /++ + Chat is completely hidden. + +/ + hidden, +} +/++ +Represents settings for a Java Edition player. ++/ +struct JavaPlayerSettings { + /++ + The player's preferred language (e.g., \"en_us\"). + +/ + WitString locale; + + /++ + The maximum distance at which chunks are rendered. + +/ + ubyte viewDistance; + + /++ + The player's chat visibility settings. + +/ + ChatMode chatMode; + + /++ + Whether chat colors are enabled. + +/ + bool chatColors; + + /++ + The player's skin configuration options. + +/ + SkinParts skinParts; + + /++ + The player's dominant hand (left or right). + +/ + Hand mainHand; + + /++ + Whether text filtering is enabled. + +/ + bool textFiltering; + + /++ + Whether the player wants to appear in the server list. + +/ + bool serverListing; + + void witFree() @nogc nothrow { + locale.witFree; + } + + void witDrop() @nogc nothrow { + } + + JavaPlayerSettings witClone() const @nogc nothrow { + JavaPlayerSettings clone = void; + clone.locale = this.locale.witClone; + clone.viewDistance = this.viewDistance.witClone; + clone.chatMode = this.chatMode.witClone; + clone.chatColors = this.chatColors.witClone; + clone.skinParts = this.skinParts.witClone; + clone.mainHand = this.mainHand.witClone; + clone.textFiltering = this.textFiltering.witClone; + clone.serverListing = this.serverListing.witClone; + return clone; + } +} + +/++ +Represents the operating system of a Bedrock Edition client. ++/ +enum BedrockDeviceOs : ubyte { + /++ + + +/ + android, + + /++ + + +/ + ios, + + /++ + + +/ + osx, + + /++ + + +/ + amazon, + + /++ + + +/ + gearVr, + + /++ + + +/ + holoLens, + + /++ + + +/ + windows10, + + /++ + + +/ + win32, + + /++ + + +/ + dedicated, + + /++ + + +/ + tvOs, + + /++ + + +/ + playstation, + + /++ + + +/ + nintendo, + + /++ + + +/ + xbox, + + /++ + + +/ + windowsPhone, + + /++ + + +/ + linux, + + /++ + Fallback for unrecognized operating systems. + +/ + unknown, +} +/++ +Represents the input mode used by a Bedrock Edition client. ++/ +enum BedrockInputMode : ubyte { + /++ + Unknown input mode. + +/ + unknown, + + /++ + Mouse and keyboard. + +/ + mouse, + + /++ + Touch screen. + +/ + touch, + + /++ + Game controller. + +/ + gamePad, + + /++ + Motion-based controller. + +/ + motionController, +} +/++ +Represents the UI profile used by a Bedrock Edition client. ++/ +enum BedrockUiProfile : ubyte { + /++ + Classic desktop UI. + +/ + classic, + + /++ + Pocket/Mobile optimized UI. + +/ + pocket, + + /++ + Unknown UI profile. + +/ + unknown, +} +/++ +Represents the graphics mode used by a Bedrock Edition client. ++/ +enum BedrockGraphicsMode : ubyte { + /++ + + +/ + simple, + + /++ + + +/ + fancy, + + /++ + + +/ + rayTraced, + + /++ + + +/ + unknown, +} +/++ +Represents settings and client data for a Bedrock Edition player. ++/ +struct BedrockPlayerSettings { + /++ + The client's specific game version string. + +/ + WitString gameVersion; + + /++ + The operating system of the client device. + +/ + BedrockDeviceOs deviceOs; + + /++ + A unique identifier for the client device. + +/ + WitString deviceId; + + /++ + The model name of the client device. + +/ + WitString deviceModel; + + /++ + The player's preferred language code (e.g., \"en_US\"). + +/ + WitString languageCode; + + /++ + The input mode currently used by the player. + +/ + BedrockInputMode currentInputMode; + + /++ + The default input mode for the client device. + +/ + BedrockInputMode defaultInputMode; + + /++ + The UI layout profile used by the client. + +/ + BedrockUiProfile uiProfile; + + /++ + The current GUI scale setting. + +/ + int guiScale; + + /++ + Whether the player is in Editor mode. + +/ + bool isEditorMode; + + /++ + The maximum view distance the client supports. + +/ + int maxViewDistance; + + /++ + The memory tier of the client device (indicates performance level). + +/ + int memoryTier; + + /++ + The graphics mode used by the client. + +/ + BedrockGraphicsMode graphicsMode; + + /++ + The player's unique PlayFab identifier. + +/ + WitString playfabId; + + /++ + A random 64-bit ID generated by the client. + +/ + long clientRandomId; + + /++ + Platform-specific offline identifier. + +/ + WitString platformOfflineId; + + /++ + Platform-specific online identifier. + +/ + WitString platformOnlineId; + + /++ + The unique ID of the player's current skin. + +/ + WitString skinId; + + /++ + The model arm size (e.g., \"wide\" or \"slim\"). + +/ + WitString armSize; + + /++ + Whether the player is using a Character Creator (Persona) skin. + +/ + bool isPersonaSkin; + + /++ + Whether the skin is a premium (paid) skin. + +/ + bool isPremiumSkin; + + /++ + Whether the skin is from a trusted source. + +/ + bool isTrustedSkin; + + void witFree() @nogc nothrow { + gameVersion.witFree; + deviceId.witFree; + deviceModel.witFree; + languageCode.witFree; + playfabId.witFree; + platformOfflineId.witFree; + platformOnlineId.witFree; + skinId.witFree; + armSize.witFree; + } + + void witDrop() @nogc nothrow { + } + + BedrockPlayerSettings witClone() const @nogc nothrow { + BedrockPlayerSettings clone = void; + clone.gameVersion = this.gameVersion.witClone; + clone.deviceOs = this.deviceOs.witClone; + clone.deviceId = this.deviceId.witClone; + clone.deviceModel = this.deviceModel.witClone; + clone.languageCode = this.languageCode.witClone; + clone.currentInputMode = this.currentInputMode.witClone; + clone.defaultInputMode = this.defaultInputMode.witClone; + clone.uiProfile = this.uiProfile.witClone; + clone.guiScale = this.guiScale.witClone; + clone.isEditorMode = this.isEditorMode.witClone; + clone.maxViewDistance = this.maxViewDistance.witClone; + clone.memoryTier = this.memoryTier.witClone; + clone.graphicsMode = this.graphicsMode.witClone; + clone.playfabId = this.playfabId.witClone; + clone.clientRandomId = this.clientRandomId.witClone; + clone.platformOfflineId = this.platformOfflineId.witClone; + clone.platformOnlineId = this.platformOnlineId.witClone; + clone.skinId = this.skinId.witClone; + clone.armSize = this.armSize.witClone; + clone.isPersonaSkin = this.isPersonaSkin.witClone; + clone.isPremiumSkin = this.isPremiumSkin.witClone; + clone.isTrustedSkin = this.isTrustedSkin.witClone; + return clone; + } +} + +/++ +Protocol-level disconnect reasons for Minecraft Bedrock Edition. ++/ +enum BedrockDisconnectReason : ubyte { + /++ + + +/ + unknown, + + /++ + + +/ + cantConnectNoInternet, + + /++ + + +/ + noPermissions, + + /++ + + +/ + unrecoverableError, + + /++ + + +/ + thirdPartyBlocked, + + /++ + + +/ + thirdPartyNoInternet, + + /++ + + +/ + thirdPartyBadIp, + + /++ + + +/ + thirdPartyNoServerOrServerLocked, + + /++ + + +/ + versionMismatch, + + /++ + + +/ + skinIssue, + + /++ + + +/ + inviteSessionNotFound, + + /++ + + +/ + eduLevelSettingsMissing, + + /++ + + +/ + localServerNotFound, + + /++ + + +/ + legacyDisconnect, + + /++ + + +/ + userLeaveGameAttempted, + + /++ + + +/ + platformLockedSkinsError, + + /++ + + +/ + realmsWorldUnassigned, + + /++ + + +/ + realmsServerCantConnect, + + /++ + + +/ + realmsServerHidden, + + /++ + + +/ + realmsServerDisabledBeta, + + /++ + + +/ + realmsServerDisabled, + + /++ + + +/ + crossPlatformDisabled, + + /++ + + +/ + cantConnect, + + /++ + + +/ + sessionNotFound, + + /++ + + +/ + clientSettingsIncompatibleWithServer, + + /++ + + +/ + serverFull, + + /++ + + +/ + invalidPlatformSkin, + + /++ + + +/ + editionVersionMismatch, + + /++ + + +/ + editionMismatch, + + /++ + + +/ + levelNewerThanExeVersion, + + /++ + + +/ + noFailOccurred, + + /++ + + +/ + bannedSkin, + + /++ + + +/ + timeout, + + /++ + + +/ + serverNotFound, + + /++ + + +/ + outdatedServer, + + /++ + + +/ + outdatedClient, + + /++ + + +/ + noPremiumPlatform, + + /++ + + +/ + multiplayerDisabled, + + /++ + + +/ + noWifi, + + /++ + + +/ + worldCorruption, + + /++ + + +/ + noReason, + + /++ + + +/ + disconnected, + + /++ + + +/ + invalidPlayer, + + /++ + + +/ + loggedInOtherLocation, + + /++ + + +/ + serverIdConflict, + + /++ + + +/ + notAllowed, + + /++ + + +/ + notAuthenticated, + + /++ + + +/ + invalidTenant, + + /++ + + +/ + unknownPacket, + + /++ + + +/ + unexpectedPacket, + + /++ + + +/ + invalidCommandRequestPacket, + + /++ + + +/ + hostSuspended, + + /++ + + +/ + loginPacketNoRequest, + + /++ + + +/ + loginPacketNoCert, + + /++ + + +/ + missingClient, + + /++ + + +/ + kicked, + + /++ + + +/ + kickedForExploit, + + /++ + + +/ + kickedForIdle, + + /++ + + +/ + resourcePackProblem, + + /++ + + +/ + incompatiblePack, + + /++ + + +/ + outOfStorage, + + /++ + + +/ + invalidLevel, + + /++ + + +/ + disconnectPacket, + + /++ + + +/ + blockMismatch, + + /++ + + +/ + invalidHeights, + + /++ + + +/ + invalidWidths, + + /++ + + +/ + connectionLost, + + /++ + + +/ + zombieConnection, + + /++ + + +/ + shutdown, + + /++ + + +/ + reasonNotSet, + + /++ + + +/ + loadingStateTimeout, + + /++ + + +/ + resourcePackLoadingFailed, + + /++ + + +/ + searchingForSessionLoadingScreenFailed, + + /++ + + +/ + netherNetProtocolVersion, + + /++ + + +/ + subsystemStatusError, + + /++ + + +/ + emptyAuthFromDiscovery, + + /++ + + +/ + emptyUrlFromDiscovery, + + /++ + + +/ + expiredAuthFromDiscovery, + + /++ + + +/ + unknownSignalServiceSignInFailure, + + /++ + + +/ + xblJoinLobbyFailure, + + /++ + + +/ + unspecifiedClientInstanceDisconnection, + + /++ + + +/ + netherNetSessionNotFound, + + /++ + + +/ + netherNetCreatePeerConnection, + + /++ + + +/ + netherNetIce, + + /++ + + +/ + netherNetConnectRequest, + + /++ + + +/ + netherNetConnectResponse, + + /++ + + +/ + netherNetNegotiationTimeout, + + /++ + + +/ + netherNetInactivityTimeout, + + /++ + + +/ + staleConnectionBeingReplaced, + + /++ + + +/ + realmsSessionNotFound, + + /++ + + +/ + badPacket, + + /++ + + +/ + netherNetFailedToCreateOffer, + + /++ + + +/ + netherNetFailedToCreateAnswer, + + /++ + + +/ + netherNetFailedToSetLocalDescription, + + /++ + + +/ + netherNetFailedToSetRemoteDescription, + + /++ + + +/ + netherNetNegotiationTimeoutWaitingForResponse, + + /++ + + +/ + netherNetNegotiationTimeoutWaitingForAccept, + + /++ + + +/ + netherNetIncomingConnectionIgnored, + + /++ + + +/ + netherNetSignalingParsingFailure, + + /++ + + +/ + netherNetSignalingUnknownError, + + /++ + + +/ + netherNetSignalingUnicastDeliveryFailed, + + /++ + + +/ + netherNetSignalingBroadcastDeliveryFailed, + + /++ + + +/ + netherNetSignalingGenericDeliveryFailed, + + /++ + + +/ + editorMismatchEditorWorld, + + /++ + + +/ + editorMismatchVanillaWorld, + + /++ + + +/ + worldTransferNotPrimaryClient, + + /++ + + +/ + requestServerShutdown, + + /++ + + +/ + clientGameSetupCancelled, + + /++ + + +/ + clientGameSetupFailed, + + /++ + + +/ + noVenue, + + /++ + + +/ + netherNetSignalingSigninFailed, + + /++ + + +/ + sessionAccessDenied, + + /++ + + +/ + serviceSigninIssue, + + /++ + + +/ + netherNetNoSignalingChannel, + + /++ + + +/ + netherNetNotLoggedIn, + + /++ + + +/ + netherNetClientSignalingError, + + /++ + + +/ + subClientLoginDisabled, + + /++ + + +/ + deepLinkTryingToOpenDemoWorldWhileSignedIn, + + /++ + + +/ + asyncJoinTaskDenied, + + /++ + + +/ + realmsTimelineRequired, + + /++ + + +/ + guestWithoutHost, + + /++ + + +/ + failedToJoinExperience, + + /++ + + +/ + netherNetDataChannelClosed, + + /++ + + +/ + discoveryEnvironmentMismatch, + + /++ + + +/ + hostWithoutKeys, + + /++ + + +/ + hostSignedOut, + + /++ + + +/ + scriptWatchdogException, + + /++ + + +/ + scriptMemoryLimitExceeded, + + /++ + + +/ + storageLowDuringGameplay, + + /++ + + +/ + storageFullDuringGameplay, + + /++ + + +/ + levelStorageCorruption, + + /++ + + +/ + editionMismatchVanillaToEdu, + + /++ + + +/ + editionMismatchEduToVanilla, + + /++ + + +/ + editorMismatchEditorToVanilla, + + /++ + + +/ + editorMismatchVanillaToEditor, + + /++ + + +/ + denyListed, + + /++ + + +/ + nonceMissing, + + /++ + + +/ + nonceNotFound, + + /++ + + +/ + nonceExpired, + + /++ + + +/ + nonceNotValid, + + /++ + + +/ + hostDisconnected, + + /++ + + +/ + editorJoinIntentPolicyFailure, + + /++ + + +/ + netherNetIdentityNotAllowed, + + /++ + + +/ + invalidName, + + /++ + + +/ + expiredToken, + + /++ + + +/ + hostAcceptsNoTypeOfAuth, + + /++ + + +/ + notAuthenticatedFastFail, + + /++ + + +/ + editorNotAllowed, +} +/++ +Policy for tearing down the player's network connection. ++/ +enum SocketTeardownPolicy : ubyte { + /++ + Send the disconnect packet and gracefully close the connection. + +/ + graceful, + + /++ + Send the disconnect packet and close the socket immediately. + +/ + immediateClose, + + /++ + Terminate the connection immediately without sending any disconnect packet. + +/ + dropConnection, +} +/++ +Options for disconnecting a Bedrock Edition player. ++/ +struct BedrockKickOptions { + /++ + Protocol level disconnect code (default: kicked). + +/ + BedrockDisconnectReason reason; + + /++ + Message displayed on the Bedrock disconnect screen (default: ""). + +/ + WitString message; + + /++ + Whether to suppress the disconnect message on the client screen (default: false). + +/ + bool skipMessage; + + /++ + Filtered message string for safety/parental filters (default: ""). + +/ + WitString filteredMessage; + + /++ + Whether to log the kick in the server console (default: true). + +/ + bool logToConsole; + + /++ + How the connection is closed (default: graceful). + +/ + SocketTeardownPolicy teardownPolicy; + + void witFree() @nogc nothrow { + message.witFree; + filteredMessage.witFree; + } + + void witDrop() @nogc nothrow { + } + + BedrockKickOptions witClone() const @nogc nothrow { + BedrockKickOptions clone = void; + clone.reason = this.reason.witClone; + clone.message = this.message.witClone; + clone.skipMessage = this.skipMessage.witClone; + clone.filteredMessage = this.filteredMessage.witClone; + clone.logToConsole = this.logToConsole.witClone; + clone.teardownPolicy = this.teardownPolicy.witClone; + return clone; + } +} + +/++ +Represents an individual Bedrock Edition resource pack entry. ++/ +struct BedrockResourcePackEntry { + /++ + Unique identifier for the Bedrock pack. + +/ + Uuid id; + + /++ + Version string of the Bedrock pack (e.g., "1.0.0"). + +/ + WitString version_; + + /++ + Size of the pack in bytes. + +/ + ulong size; + + /++ + Download URL for remote Bedrock packs. + +/ + WitString downloadUrl; + + /++ + Optional encryption content key for encrypted packs. + +/ + Option!(WitString) contentKey; + + /++ + Optional sub-pack name inside the archive. + +/ + Option!(WitString) subPackName; + + /++ + Optional content identifier. + +/ + Option!(WitString) contentId; + + /++ + Whether the pack contains client scripts. + +/ + bool hasScripts; + + /++ + Whether the pack is marked as an addon pack. + +/ + bool addonPack; + + /++ + Whether Ray Tracing / RTX features are enabled for the pack. + +/ + bool rtxEnabled; + + void witFree() @nogc nothrow { + version_.witFree; + downloadUrl.witFree; + contentKey.witFree; + subPackName.witFree; + contentId.witFree; + } + + void witDrop() @nogc nothrow { + } + + BedrockResourcePackEntry witClone() const @nogc nothrow { + BedrockResourcePackEntry clone = void; + clone.id = this.id.witClone; + clone.version_ = this.version_.witClone; + clone.size = this.size.witClone; + clone.downloadUrl = this.downloadUrl.witClone; + clone.contentKey = this.contentKey.witClone; + clone.subPackName = this.subPackName.witClone; + clone.contentId = this.contentId.witClone; + clone.hasScripts = this.hasScripts.witClone; + clone.addonPack = this.addonPack.witClone; + clone.rtxEnabled = this.rtxEnabled.witClone; + return clone; + } +} + +/++ +Represents the resource packs information payload sent to Bedrock clients. ++/ +struct BedrockResourcePacksInfo { + /++ + If true, players cannot join without accepting packs. + +/ + bool required; + + /++ + Whether the server offers addon packs. + +/ + bool hasAddonPacks; + + /++ + Whether any of the packs contain client scripts. + +/ + bool hasScripts; + + /++ + Whether vibrant visuals should be forced disabled. + +/ + bool isVibrantVisualsForceDisabled; + + /++ + World template ID, if any. + +/ + Option!(Uuid) worldTemplateId; + + /++ + World template version, if any. + +/ + Option!(WitString) worldTemplateVersion; + + /++ + List of resource packs to send to the player. + +/ + WitList!(BedrockResourcePackEntry) packs; + + void witFree() @nogc nothrow { + worldTemplateVersion.witFree; + packs.witFree; + } + + void witDrop() @nogc nothrow { + } + + BedrockResourcePacksInfo witClone() const @nogc nothrow { + BedrockResourcePacksInfo clone = void; + clone.required = this.required.witClone; + clone.hasAddonPacks = this.hasAddonPacks.witClone; + clone.hasScripts = this.hasScripts.witClone; + clone.isVibrantVisualsForceDisabled = this.isVibrantVisualsForceDisabled.witClone; + clone.worldTemplateId = this.worldTemplateId.witClone; + clone.worldTemplateVersion = this.worldTemplateVersion.witClone; + clone.packs = this.packs.witClone; + return clone; + } +} diff --git a/src/wit/pumpkin/plugin/player/imports.d b/src/wit/pumpkin/plugin/player/imports.d new file mode 100644 index 0000000..842c71f --- /dev/null +++ b/src/wit/pumpkin/plugin/player/imports.d @@ -0,0 +1,8216 @@ +/++ +Represents a player connected to the Minecraft server. ++/ +module wit.pumpkin.plugin.player.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.player.common; + +static import wit.pumpkin.plugin.common.imports; +static import wit.pumpkin.plugin.damage_types.imports; +static import wit.pumpkin.plugin.entity_statuses.imports; +static import wit.pumpkin.plugin.particles.imports; +static import wit.pumpkin.plugin.permission.imports; +static import wit.pumpkin.plugin.sounds.imports; +static import wit.pumpkin.plugin.statistics.imports; +static import wit.pumpkin.plugin.status_effect.imports; +static import wit.pumpkin.plugin.text.imports; +static import wit.pumpkin.plugin.advancement.imports; +static import wit.pumpkin.plugin.forms.imports; +static import wit.pumpkin.plugin.item_stack.imports; +static import wit.pumpkin.plugin.inventory.imports; +static import wit.pumpkin.plugin.gui.imports; +static import wit.pumpkin.plugin.java_dialogs.imports; +static import wit.pumpkin.plugin.scoreboard.imports; +static import wit.pumpkin.plugin.uuid.imports; +static import wit.pumpkin.plugin.bedrock_packets.imports; +static import wit.pumpkin.plugin.java_packets.imports; +static import wit.pumpkin.plugin.world.imports; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias ItemStack = wit.pumpkin.plugin.item_stack.imports.ItemStack; + +/++ + ++/ +alias World = wit.pumpkin.plugin.world.imports.World; + +/++ + ++/ +alias Entity = wit.pumpkin.plugin.world.imports.Entity; + +/++ + ++/ +alias RayTraceEntityResult = wit.pumpkin.plugin.world.imports.RayTraceEntityResult; + +/++ + ++/ +alias TextComponent = wit.pumpkin.plugin.text.imports.TextComponent; + +/++ + ++/ +alias Gui = wit.pumpkin.plugin.gui.imports.Gui; + +/++ + ++/ +alias Form = wit.pumpkin.plugin.forms.imports.Form; + +/++ + ++/ +alias Dialog = wit.pumpkin.plugin.java_dialogs.imports.Dialog; + +/++ + ++/ +alias Scoreboard = wit.pumpkin.plugin.scoreboard.imports.Scoreboard; + +/++ + ++/ +alias BedrockScoreboard = wit.pumpkin.plugin.scoreboard.imports.BedrockScoreboard; + +/++ + ++/ +alias Inventory = wit.pumpkin.plugin.inventory.imports.Inventory; + +/++ + ++/ +alias PlayerInventory = wit.pumpkin.plugin.inventory.imports.PlayerInventory; + +/++ +Label for a server link: either a built-in standard link type or a custom text component. ++/ +struct ServerLinkLabel { + mixin WitVariant!( + KnownServerLink, // known + TextComponent, // custom + ); + +public: + enum Tag : ubyte { + /++ + + +/ + known, + + /++ + + +/ + custom, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias known = _create!(Tag.known); + /// ditto + pragma(inline, true) bool isKnown() const => _tag == Tag.known; + ///ditto + alias getKnown = _get!(Tag.known); + + /++ + + +/ + alias custom = _create!(Tag.custom); + /// ditto + pragma(inline, true) bool isCustom() const => _tag == Tag.custom; + ///ditto + alias getCustom = _get!(Tag.custom); + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + switch (_tag) with (Tag) { + case custom: _get!(Tag.custom).witDrop; break; + default: break; + } + } + + ServerLinkLabel witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.known: return _create!(Tag.known)(this._get!(Tag.known).witClone); break; + case Tag.custom: return _create!(Tag.custom)(this._get!(Tag.custom).witClone); break; + } + } +} + +/++ +Represents a server link entry with a label and destination URL. ++/ +struct ServerLink { + /++ + + +/ + ServerLinkLabel label; + + /++ + + +/ + WitString url; + + void witFree() @nogc nothrow { + url.witFree; + } + + void witDrop() @nogc nothrow { + label.witDrop; + } + + ServerLink witClone() const @nogc nothrow { + ServerLink clone = void; + clone.label = this.label.witClone; + clone.url = this.url.witClone; + return clone; + } +} + +/++ +Options for disconnecting a Java Edition player. ++/ +struct JavaKickOptions { + /++ + The formatted text component displayed on the Java disconnect screen. + +/ + TextComponent reason; + + /++ + Whether to log the kick in the server console (default: true). + +/ + bool logToConsole; + + /++ + How the connection is closed (default: graceful). + +/ + SocketTeardownPolicy teardownPolicy; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + reason.witDrop; + } + + JavaKickOptions witClone() const @nogc nothrow { + JavaKickOptions clone = void; + clone.reason = this.reason.witClone; + clone.logToConsole = this.logToConsole.witClone; + clone.teardownPolicy = this.teardownPolicy.witClone; + return clone; + } +} + +/++ +Options for banning a player. ++/ +struct BanPlayerOptions { + /++ + Ban reason displayed to the player and stored in the ban list. + +/ + Option!(TextComponent) reason; + + /++ + Source or authority responsible for the ban (default: "Plugin"). + +/ + Option!(WitString) source; + + /++ + Ban expiration in RFC-3339 format, if temporary. + +/ + Option!(WitString) expiresAtUtc; + + /++ + Ban duration in seconds from now, if temporary. + +/ + Option!(ulong) durationSeconds; + + /++ + Whether to immediately kick the player if currently online (default: true). + +/ + bool kickIfOnline; + + /++ + Whether to log the ban action to the server console (default: true). + +/ + bool logToConsole; + + void witFree() @nogc nothrow { + source.witFree; + expiresAtUtc.witFree; + } + + void witDrop() @nogc nothrow { + reason.witDrop; + } + + BanPlayerOptions witClone() const @nogc nothrow { + BanPlayerOptions clone = void; + clone.reason = this.reason.witClone; + clone.source = this.source.witClone; + clone.expiresAtUtc = this.expiresAtUtc.witClone; + clone.durationSeconds = this.durationSeconds.witClone; + clone.kickIfOnline = this.kickIfOnline.witClone; + clone.logToConsole = this.logToConsole.witClone; + return clone; + } +} + +/++ +Options for banning an IP address. ++/ +struct BanIpOptions { + /++ + Ban reason stored in the IP ban list. + +/ + Option!(TextComponent) reason; + + /++ + Source or authority responsible for the ban (default: "Plugin"). + +/ + Option!(WitString) source; + + /++ + Ban expiration in RFC-3339 format, if temporary. + +/ + Option!(WitString) expiresAtUtc; + + /++ + Ban duration in seconds from now, if temporary. + +/ + Option!(ulong) durationSeconds; + + /++ + Whether to immediately kick all online players with this IP (default: true). + +/ + bool kickMatchingPlayers; + + /++ + Whether to log the IP ban action to the server console (default: true). + +/ + bool logToConsole; + + void witFree() @nogc nothrow { + source.witFree; + expiresAtUtc.witFree; + } + + void witDrop() @nogc nothrow { + reason.witDrop; + } + + BanIpOptions witClone() const @nogc nothrow { + BanIpOptions clone = void; + clone.reason = this.reason.witClone; + clone.source = this.source.witClone; + clone.expiresAtUtc = this.expiresAtUtc.witClone; + clone.durationSeconds = this.durationSeconds.witClone; + clone.kickMatchingPlayers = this.kickMatchingPlayers.witClone; + clone.logToConsole = this.logToConsole.witClone; + return clone; + } +} + +/++ +A handle to a player on the server. ++/ +struct Player { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/player@0.1.0", "[resource-drop]player") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:resource_drop:player") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + Returns the player as an entity. + +/ + Entity asEntity() @trusted nothrow { + auto _ret = __import_asEntity(this.__handle); + auto _handle0 = Entity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.as-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.as_entity") + static private extern(C) uint __import_asEntity(uint) nothrow; + + /++ + Returns the player's unique UUID as a string. + +/ + Uuid getId() @trusted nothrow { + align(8) void[16] _retArea = void; + __import_getId(this.__handle, _retArea.ptr); + wit.pumpkin.plugin.uuid.imports.Uuid _record0 = { + high: *(cast(ulong*)(_retArea.ptr + 0)), + low: *(cast(ulong*)(_retArea.ptr + 8)), + }; + auto _flush1 = _record0; + return _flush1; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-id") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_id") + static private extern(C) void __import_getId(uint, void*) nothrow; + + /++ + Returns the player's username. + +/ + WitString getName() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getName(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-name") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_name") + static private extern(C) void __import_getName(uint, void*) nothrow; + + /++ + Basic state + Returns the player's current position in the world. + +/ + Position getPosition() @trusted nothrow { + align(8) void[24] _retArea = void; + __import_getPosition(this.__handle, _retArea.ptr); + auto _tuple0 = wit.pumpkin.plugin.common.imports.Position( + *(cast(double*)(_retArea.ptr + 0)), + *(cast(double*)(_retArea.ptr + 8)), + *(cast(double*)(_retArea.ptr + 16)), + ); + auto _flush1 = _tuple0; + return _flush1; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-position") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_position") + static private extern(C) void __import_getPosition(uint, void*) nothrow; + + /++ + Returns the player's current yaw (horizontal rotation). + +/ + float getYaw() @trusted nothrow { + auto _ret = __import_getYaw(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-yaw") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_yaw") + static private extern(C) float __import_getYaw(uint) nothrow; + + /++ + Returns the player's current pitch (vertical rotation). + +/ + float getPitch() @trusted nothrow { + auto _ret = __import_getPitch(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-pitch") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_pitch") + static private extern(C) float __import_getPitch(uint) nothrow; + + /++ + Returns the world the player is currently in. + +/ + World getWorld() @trusted nothrow { + auto _ret = __import_getWorld(this.__handle); + auto _handle0 = World(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-world") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_world") + static private extern(C) uint __import_getWorld(uint) nothrow; + + /++ + Returns the player's current game mode. + +/ + GameMode getGamemode() @trusted nothrow { + auto _ret = __import_getGamemode(this.__handle); + return cast(wit.pumpkin.plugin.common.imports.GameMode)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-gamemode") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_gamemode") + static private extern(C) uint __import_getGamemode(uint) nothrow; + + /++ + Changes the player's game mode. Returns true if successful. + +/ + bool setGamemode(GameMode mode) @trusted nothrow { + auto _ret = __import_setGamemode(this.__handle, cast(uint)(mode)); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-gamemode") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_gamemode") + static private extern(C) uint __import_setGamemode(uint, uint) nothrow; + + /++ + Returns the player's locale (e.g., \"en_us\"). + +/ + WitString getLocale() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getLocale(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-locale") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_locale") + static private extern(C) void __import_getLocale(uint, void*) nothrow; + + /++ + Returns the player's current ping in milliseconds. + +/ + uint getPing() @trusted nothrow { + auto _ret = __import_getPing(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-ping") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_ping") + static private extern(C) uint __import_getPing(uint) nothrow; + + /++ + Permissions & metadata + Returns the player's permission level (0-4). + +/ + PermissionLevel getPermissionLevel() @trusted nothrow { + auto _ret = __import_getPermissionLevel(this.__handle); + return cast(wit.pumpkin.plugin.permission.imports.PermissionLevel)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-permission-level") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_permission_level") + static private extern(C) uint __import_getPermissionLevel(uint) nothrow; + + /++ + Sets the player's permission level. + +/ + void setPermissionLevel(PermissionLevel level) @trusted nothrow { + __import_setPermissionLevel(this.__handle, cast(uint)(level)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-permission-level") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_permission_level") + static private extern(C) void __import_setPermissionLevel(uint, uint) nothrow; + + /++ + Grants or denies a specific permission node for the player. + +/ + void setPermission(in WitString node, bool value) @trusted nothrow { + __import_setPermission(this.__handle, cast(void*)(node.ptr), node.length, cast(uint)(value)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-permission") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_permission") + static private extern(C) void __import_setPermission(uint, void*, size_t, uint) nothrow; + + /++ + Removes an explicitly set permission node from the player. + +/ + void unsetPermission(in WitString node) @trusted nothrow { + __import_unsetPermission(this.__handle, cast(void*)(node.ptr), node.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.unset-permission") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.unset_permission") + static private extern(C) void __import_unsetPermission(uint, void*, size_t) nothrow; + + /++ + Returns `Some(true)` if granted, `Some(false)` if denied, or `None` if not set. + +/ + Option!(bool) hasPermissionSet(in WitString node) @trusted nothrow { + align(1) void[2] _retArea = void; + __import_hasPermissionSet(this.__handle, cast(void*)(node.ptr), node.length, _retArea.ptr); + Option!(bool) _option2 = void; + bool _isSome2 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome2) { + + _option2 = Option!(bool).makeSome((cast(uint)(*(cast(ubyte*)(_retArea.ptr + 1)))) != 0); + } else { + _option2 = Option!(bool).makeNone; + } + auto _flush3 = _option2; + return _flush3; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.has-permission-set") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.has_permission_set") + static private extern(C) void __import_hasPermissionSet(uint, void*, size_t, void*) nothrow; + + /++ + Checks if the player has a specific permission node. + +/ + bool hasPermission(in WitString node) @trusted nothrow { + auto _ret = __import_hasPermission(this.__handle, cast(void*)(node.ptr), node.length); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.has-permission") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.has_permission") + static private extern(C) uint __import_hasPermission(uint, void*, size_t) nothrow; + + /++ + Returns the player's display name, which may include formatting. + +/ + TextComponent getDisplayName() @trusted nothrow { + auto _ret = __import_getDisplayName(this.__handle); + auto _handle0 = TextComponent(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-display-name") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_display_name") + static private extern(C) uint __import_getDisplayName(uint) nothrow; + + /++ + Sets the player's display name. + +/ + void setDisplayName(TextComponent displayName) @trusted nothrow { + __import_setDisplayName(this.__handle, displayName.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-display-name") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_display_name") + static private extern(C) void __import_setDisplayName(uint, uint) nothrow; + + /++ + Gets the player's custom tab list name. + +/ + Option!(TextComponent) getTabListName() @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getTabListName(this.__handle, _retArea.ptr); + Option!(TextComponent) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = TextComponent(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(TextComponent).makeSome(_handle2); + } else { + _option3 = Option!(TextComponent).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-tab-list-name") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_tab_list_name") + static private extern(C) void __import_getTabListName(uint, void*) nothrow; + + /++ + Sets the player's custom tab list name. + +/ + void setTabListName(in Option!(TextComponent) name) @trusted nothrow { + uint _option4 = void; + uint _option5 = void; + if (name.isSome) { + ref _payload3 = name.unwrap(); + _option4 = 1; + _option5 = _payload3.__handle; + } else { + _option4 = 0; + _option5 = 0; + } + __import_setTabListName(this.__handle, _option4, _option5); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-tab-list-name") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_tab_list_name") + static private extern(C) void __import_setTabListName(uint, uint, uint) nothrow; + + /++ + Messaging & titles + Sends a system message to the player's chat. + +/ + void sendSystemMessage(TextComponent text, bool overlay) @trusted nothrow { + __import_sendSystemMessage(this.__handle, text.__handle, cast(uint)(overlay)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.send-system-message") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.send_system_message") + static private extern(C) void __import_sendSystemMessage(uint, uint, uint) nothrow; + + /++ + Deletes a signed chat message from the player's chat window using its 256-byte signature. + +/ + void deleteMessageBySignature(in WitList!(ubyte) signature) @trusted nothrow { + __import_deleteMessageBySignature(this.__handle, cast(void*)(signature.ptr), signature.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.delete-message-by-signature") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.delete_message_by_signature") + static private extern(C) void __import_deleteMessageBySignature(uint, void*, size_t) nothrow; + + /++ + Deletes a signed chat message from the player's chat window using its signature cache ID. + +/ + void deleteMessageById(int signatureId) @trusted nothrow { + __import_deleteMessageById(this.__handle, cast(uint)(signatureId)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.delete-message-by-id") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.delete_message_by_id") + static private extern(C) void __import_deleteMessageById(uint, uint) nothrow; + + /++ + Sets the header and footer of the player's Tab list. + +/ + void setTabListHeaderFooter(TextComponent header, TextComponent footer) @trusted nothrow { + __import_setTabListHeaderFooter(this.__handle, header.__handle, footer.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-tab-list-header-footer") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_tab_list_header_footer") + static private extern(C) void __import_setTabListHeaderFooter(uint, uint, uint) nothrow; + + /++ + Sets the sorting order of the player in the Tab list. + +/ + void setTabListOrder(int order) @trusted nothrow { + __import_setTabListOrder(this.__handle, cast(uint)(order)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-tab-list-order") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_tab_list_order") + static private extern(C) void __import_setTabListOrder(uint, uint) nothrow; + + /++ + Sets the latency (ping) shown for the player in the Tab list. + +/ + void setTabListLatency(int latency) @trusted nothrow { + __import_setTabListLatency(this.__handle, cast(uint)(latency)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-tab-list-latency") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_tab_list_latency") + static private extern(C) void __import_setTabListLatency(uint, uint) nothrow; + + /++ + Sets whether the player is visible in the Tab list. + +/ + void setTabListListed(bool listed) @trusted nothrow { + __import_setTabListListed(this.__handle, cast(uint)(listed)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-tab-list-listed") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_tab_list_listed") + static private extern(C) void __import_setTabListListed(uint, uint) nothrow; + + /++ + Shows a large title on the player's screen. + +/ + void showTitle(TextComponent text) @trusted nothrow { + __import_showTitle(this.__handle, text.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.show-title") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.show_title") + static private extern(C) void __import_showTitle(uint, uint) nothrow; + + /++ + Shows a smaller subtitle on the player's screen. + +/ + void showSubtitle(TextComponent text) @trusted nothrow { + __import_showSubtitle(this.__handle, text.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.show-subtitle") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.show_subtitle") + static private extern(C) void __import_showSubtitle(uint, uint) nothrow; + + /++ + Shows a message in the action bar area. + +/ + void showActionbar(TextComponent text) @trusted nothrow { + __import_showActionbar(this.__handle, text.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.show-actionbar") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.show_actionbar") + static private extern(C) void __import_showActionbar(uint, uint) nothrow; + + /++ + Sets the fade-in, stay, and fade-out times for titles. + +/ + void sendTitleAnimation(int fadeIn, int stay, int fadeOut) @trusted nothrow { + __import_sendTitleAnimation(this.__handle, cast(uint)(fadeIn), cast(uint)(stay), cast(uint)(fadeOut)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.send-title-animation") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.send_title_animation") + static private extern(C) void __import_sendTitleAnimation(uint, uint, uint, uint) nothrow; + + /++ + Camera & Spectating + Sets the player's camera to view from the perspective of another entity. + If `entity` is `none`, the camera is reset back to the player. + +/ + void setCamera(in Option!(Entity) entity) @trusted nothrow { + uint _option4 = void; + uint _option5 = void; + if (entity.isSome) { + ref _payload3 = entity.unwrap(); + _option4 = 1; + _option5 = _payload3.__handle; + } else { + _option4 = 0; + _option5 = 0; + } + __import_setCamera(this.__handle, _option4, _option5); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-camera") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_camera") + static private extern(C) void __import_setCamera(uint, uint, uint) nothrow; + + /++ + Sets the player's camera to view from the perspective of an entity with the given entity ID. + If `entity-id` is the player's own entity ID, the camera is reset back to the player. + +/ + void setCameraEntityId(uint entityId) @trusted nothrow { + __import_setCameraEntityId(this.__handle, entityId); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-camera-entity-id") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_camera_entity_id") + static private extern(C) void __import_setCameraEntityId(uint, uint) nothrow; + + /++ + Gets the entity ID of the entity that the player's camera is currently attached to, + or the player's own entity ID if the camera has not been overridden. + +/ + uint getCameraEntityId() @trusted nothrow { + auto _ret = __import_getCameraEntityId(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-camera-entity-id") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_camera_entity_id") + static private extern(C) uint __import_getCameraEntityId(uint) nothrow; + + /++ + Resets the player's camera back to their own perspective. + +/ + void resetCamera() @trusted nothrow { + __import_resetCamera(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.reset-camera") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.reset_camera") + static private extern(C) void __import_resetCamera(uint) nothrow; + + /++ + Audio & Particles + Plays a sound effect for this player at their current location. + +/ + void playSound(Sound sound, SoundCategory category, float volume, float pitch) @trusted nothrow { + __import_playSound(this.__handle, cast(uint)(sound), cast(uint)(category), volume, pitch); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.play-sound") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.play_sound") + static private extern(C) void __import_playSound(uint, uint, uint, float, float) nothrow; + + /++ + Plays a sound effect for this player at a specific location. + +/ + void playSoundAt(in Position pos, Sound sound, SoundCategory category, float volume, float pitch) @trusted nothrow { + __import_playSoundAt(this.__handle, pos[0], pos[1], pos[2], cast(uint)(sound), cast(uint)(category), volume, pitch); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.play-sound-at") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.play_sound_at") + static private extern(C) void __import_playSoundAt(uint, double, double, double, uint, uint, float, float) nothrow; + + /++ + Stops a sound effect from playing for this player. + +/ + void stopSound(in Option!(Sound) sound, in Option!(SoundCategory) category) @trusted nothrow { + uint _option4 = void; + uint _option5 = void; + if (sound.isSome) { + ref _payload3 = sound.unwrap(); + _option4 = 1; + _option5 = cast(uint)(_payload3); + } else { + _option4 = 0; + _option5 = 0; + } + uint _option10 = void; + uint _option11 = void; + if (category.isSome) { + ref _payload9 = category.unwrap(); + _option10 = 1; + _option11 = cast(uint)(_payload9); + } else { + _option10 = 0; + _option11 = 0; + } + __import_stopSound(this.__handle, _option4, _option5, _option10, _option11); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.stop-sound") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.stop_sound") + static private extern(C) void __import_stopSound(uint, uint, uint, uint, uint) nothrow; + + /++ + Plays a custom resource pack sound identifier for this player at their current location. + +/ + void playCustomSound(in WitString soundName, SoundCategory category, float volume, float pitch) @trusted nothrow { + __import_playCustomSound(this.__handle, cast(void*)(soundName.ptr), soundName.length, cast(uint)(category), volume, pitch); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.play-custom-sound") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.play_custom_sound") + static private extern(C) void __import_playCustomSound(uint, void*, size_t, uint, float, float) nothrow; + + /++ + Plays a custom resource pack sound identifier for this player at a specific location. + +/ + void playCustomSoundAt(in Position pos, in WitString soundName, SoundCategory category, float volume, float pitch) @trusted nothrow { + __import_playCustomSoundAt(this.__handle, pos[0], pos[1], pos[2], cast(void*)(soundName.ptr), soundName.length, cast(uint)(category), volume, pitch); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.play-custom-sound-at") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.play_custom_sound_at") + static private extern(C) void __import_playCustomSoundAt(uint, double, double, double, void*, size_t, uint, float, float) nothrow; + + /++ + Stops a custom sound identifier from playing for this player. + +/ + void stopCustomSound(in Option!(WitString) soundName, in Option!(SoundCategory) category) @trusted nothrow { + uint _option4 = void; + void* _option5 = void; + size_t _option6 = void; + if (soundName.isSome) { + ref _payload3 = soundName.unwrap(); + _option4 = 1; + _option5 = cast(void*)(_payload3.ptr); + _option6 = _payload3.length; + } else { + _option4 = 0; + _option5 = null; + _option6 = 0; + } + uint _option11 = void; + uint _option12 = void; + if (category.isSome) { + ref _payload10 = category.unwrap(); + _option11 = 1; + _option12 = cast(uint)(_payload10); + } else { + _option11 = 0; + _option12 = 0; + } + __import_stopCustomSound(this.__handle, _option4, _option5, _option6, _option11, _option12); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.stop-custom-sound") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.stop_custom_sound") + static private extern(C) void __import_stopCustomSound(uint, uint, void*, size_t, uint, uint) nothrow; + + /++ + Spawns particles visible only to this player. + +/ + void spawnParticles(Particle particle, in Position pos, uint count, in Position offset, float maxSpeed) @trusted nothrow { + __import_spawnParticles(this.__handle, cast(uint)(particle), pos[0], pos[1], pos[2], count, offset[0], offset[1], offset[2], maxSpeed); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.spawn-particles") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.spawn_particles") + static private extern(C) void __import_spawnParticles(uint, uint, double, double, double, uint, double, double, double, float) nothrow; + + /++ + Visuals & Client Overrides + Sends a temporary fake block change to the player's client without modifying the server world. + +/ + void sendBlockChange(in BlockPos pos, ushort blockId) @trusted nothrow { + __import_sendBlockChange(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z), cast(uint)(blockId)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.send-block-change") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.send_block_change") + static private extern(C) void __import_sendBlockChange(uint, uint, uint, uint, uint) nothrow; + + /++ + Resets a temporary fake block change by resending the actual world block at that position. + +/ + void resetBlockChange(in BlockPos pos) @trusted nothrow { + __import_resetBlockChange(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.reset-block-change") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.reset_block_change") + static private extern(C) void __import_resetBlockChange(uint, uint, uint, uint) nothrow; + + /++ + Sends a hurt / damage-tilt animation to the player's client (causes screen shake in the given yaw direction). + +/ + void sendHurtAnimation(float yaw) @trusted nothrow { + __import_sendHurtAnimation(this.__handle, yaw); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.send-hurt-animation") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.send_hurt_animation") + static private extern(C) void __import_sendHurtAnimation(uint, float) nothrow; + + /++ + Opens a written book interface for the player from the specified hand. + +/ + void openBook(Hand hand) @trusted nothrow { + __import_openBook(this.__handle, cast(uint)(hand)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.open-book") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.open_book") + static private extern(C) void __import_openBook(uint, uint) nothrow; + + /++ + Forces the sign text editor to open for the player at the specified sign block position. + +/ + void openSignEditor(in BlockPos pos, bool isFrontText) @trusted nothrow { + __import_openSignEditor(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z), cast(uint)(isFrontText)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.open-sign-editor") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.open_sign_editor") + static private extern(C) void __import_openSignEditor(uint, uint, uint, uint, uint) nothrow; + + /++ + Velocity & Physics + Sets the player's velocity / motion vector. + +/ + void setVelocity(in Position velocity) @trusted nothrow { + __import_setVelocity(this.__handle, velocity[0], velocity[1], velocity[2]); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-velocity") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_velocity") + static private extern(C) void __import_setVelocity(uint, double, double, double) nothrow; + + /++ + Applies directional knockback impulse to the player. + +/ + void applyKnockback(double strength, double x, double z) @trusted nothrow { + __import_applyKnockback(this.__handle, strength, x, z); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.apply-knockback") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.apply_knockback") + static private extern(C) void __import_applyKnockback(uint, double, double, double) nothrow; + + /++ + Movement Lock & Freezing + Sets whether the player's movement is locked (frozen in place) for cutscenes and NPC dialogues. + +/ + void setMovementLocked(bool locked) @trusted nothrow { + __import_setMovementLocked(this.__handle, cast(uint)(locked)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-movement-locked") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_movement_locked") + static private extern(C) void __import_setMovementLocked(uint, uint) nothrow; + + /++ + Returns whether the player's movement is currently locked. + +/ + bool isMovementLocked() @trusted nothrow { + auto _ret = __import_isMovementLocked(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.is-movement-locked") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.is_movement_locked") + static private extern(C) uint __import_isMovementLocked(uint) nothrow; + + /++ + Sets the number of freeze ticks on the player (controlling the powdered snow / frostbite screen vignette). + +/ + void setFreezeTicks(int ticks) @trusted nothrow { + __import_setFreezeTicks(this.__handle, cast(uint)(ticks)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-freeze-ticks") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_freeze_ticks") + static private extern(C) void __import_setFreezeTicks(uint, uint) nothrow; + + /++ + Returns the current number of freeze ticks on the player. + +/ + int getFreezeTicks() @trusted nothrow { + auto _ret = __import_getFreezeTicks(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-freeze-ticks") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_freeze_ticks") + static private extern(C) uint __import_getFreezeTicks(uint) nothrow; + + /++ + Sends custom server links to the player (displayed in the client Esc pause menu in 1.21+). + +/ + void setServerLinks(in WitList!(ServerLink) links) @trusted nothrow { + wit.common.DeallocateBuffer deallocate; + auto _listSrc6 = links; + auto _list6 = _listSrc6.length ? wit.common.malloc(_listSrc6.length * ((8+2*size_t.sizeof))) : null; + assert(!_listSrc6.length || _list6); + if (_listSrc6.length) deallocate ~= _list6; + foreach (_elem0_idx, ref _elem0; _listSrc6) { + auto _base0 = _list6 + _elem0_idx * ((8+2*size_t.sizeof)); + alias _Tag5 = ServerLinkLabel.Tag; + final switch (_elem0.label.tag) { + case _Tag5.known: { + const ref KnownServerLink _payload2 = _elem0.label.getKnown(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(0); + *cast(ubyte*)(_base0 + 4) = cast(ubyte)(cast(uint)(_payload2)); + break; + } + case _Tag5.custom: { + const ref TextComponent _payload4 = _elem0.label.getCustom(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(1); + *cast(uint*)(_base0 + 4) = cast(uint)(_payload4.__handle); + break; + } + } + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_elem0.url.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_elem0.url.ptr)); + + } + __import_setServerLinks(this.__handle, _list6, links.length); + deallocate.purge(); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-server-links") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_server_links") + static private extern(C) void __import_setServerLinks(uint, void*, size_t) nothrow; + + /++ + Teleport & kick + Teleports the player to a position in a world. + +/ + void teleport(in Position position, in Option!(float) yaw, in Option!(float) pitch, World world) @trusted nothrow { + uint _option4 = void; + float _option5 = void; + if (yaw.isSome) { + ref _payload3 = yaw.unwrap(); + _option4 = 1; + _option5 = _payload3; + } else { + _option4 = 0; + _option5 = 0; + } + uint _option10 = void; + float _option11 = void; + if (pitch.isSome) { + ref _payload9 = pitch.unwrap(); + _option10 = 1; + _option11 = _payload9; + } else { + _option10 = 0; + _option11 = 0; + } + __import_teleport(this.__handle, position[0], position[1], position[2], _option4, _option5, _option10, _option11, world.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.teleport") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.teleport") + static private extern(C) void __import_teleport(uint, double, double, double, uint, float, uint, float, uint) nothrow; + + /++ + Teleports the player to another world at a specific position. + +/ + void teleportWorld(World worldRef, in Position position, in Option!(float) yaw, in Option!(float) pitch) @trusted nothrow { + uint _option4 = void; + float _option5 = void; + if (yaw.isSome) { + ref _payload3 = yaw.unwrap(); + _option4 = 1; + _option5 = _payload3; + } else { + _option4 = 0; + _option5 = 0; + } + uint _option10 = void; + float _option11 = void; + if (pitch.isSome) { + ref _payload9 = pitch.unwrap(); + _option10 = 1; + _option11 = _payload9; + } else { + _option10 = 0; + _option11 = 0; + } + __import_teleportWorld(this.__handle, worldRef.__handle, position[0], position[1], position[2], _option4, _option5, _option10, _option11); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.teleport-world") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.teleport_world") + static private extern(C) void __import_teleportWorld(uint, uint, double, double, double, uint, float, uint, float) nothrow; + + /++ + Forces the player to respawn. + +/ + void respawn() @trusted nothrow { + __import_respawn(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.respawn") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.respawn") + static private extern(C) void __import_respawn(uint) nothrow; + + /++ + Opens a GUI for the player. + +/ + void openGui(Gui guiRef) @trusted nothrow { + __import_openGui(this.__handle, guiRef.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.open-gui") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.open_gui") + static private extern(C) void __import_openGui(uint, uint) nothrow; + + /++ + Bans the player with the specified options. + +/ + void ban(in BanPlayerOptions options) @trusted nothrow { + uint _option4 = void; + uint _option5 = void; + if (options.reason.isSome) { + ref _payload3 = options.reason.unwrap(); + _option4 = 1; + _option5 = _payload3.__handle; + } else { + _option4 = 0; + _option5 = 0; + } + uint _option10 = void; + void* _option11 = void; + size_t _option12 = void; + if (options.source.isSome) { + ref _payload9 = options.source.unwrap(); + _option10 = 1; + _option11 = cast(void*)(_payload9.ptr); + _option12 = _payload9.length; + } else { + _option10 = 0; + _option11 = null; + _option12 = 0; + } + uint _option17 = void; + void* _option18 = void; + size_t _option19 = void; + if (options.expiresAtUtc.isSome) { + ref _payload16 = options.expiresAtUtc.unwrap(); + _option17 = 1; + _option18 = cast(void*)(_payload16.ptr); + _option19 = _payload16.length; + } else { + _option17 = 0; + _option18 = null; + _option19 = 0; + } + uint _option24 = void; + ulong _option25 = void; + if (options.durationSeconds.isSome) { + ref _payload23 = options.durationSeconds.unwrap(); + _option24 = 1; + _option25 = _payload23; + } else { + _option24 = 0; + _option25 = 0; + } + __import_ban(this.__handle, _option4, _option5, _option10, _option11, _option12, _option17, _option18, _option19, _option24, _option25, cast(uint)(options.kickIfOnline), cast(uint)(options.logToConsole)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.ban") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.ban") + static private extern(C) void __import_ban(uint, uint, uint, uint, void*, size_t, uint, void*, size_t, uint, ulong, uint, uint) nothrow; + + /++ + Bans the player's IP address with the specified options. + +/ + void banIp(in BanIpOptions options) @trusted nothrow { + uint _option4 = void; + uint _option5 = void; + if (options.reason.isSome) { + ref _payload3 = options.reason.unwrap(); + _option4 = 1; + _option5 = _payload3.__handle; + } else { + _option4 = 0; + _option5 = 0; + } + uint _option10 = void; + void* _option11 = void; + size_t _option12 = void; + if (options.source.isSome) { + ref _payload9 = options.source.unwrap(); + _option10 = 1; + _option11 = cast(void*)(_payload9.ptr); + _option12 = _payload9.length; + } else { + _option10 = 0; + _option11 = null; + _option12 = 0; + } + uint _option17 = void; + void* _option18 = void; + size_t _option19 = void; + if (options.expiresAtUtc.isSome) { + ref _payload16 = options.expiresAtUtc.unwrap(); + _option17 = 1; + _option18 = cast(void*)(_payload16.ptr); + _option19 = _payload16.length; + } else { + _option17 = 0; + _option18 = null; + _option19 = 0; + } + uint _option24 = void; + ulong _option25 = void; + if (options.durationSeconds.isSome) { + ref _payload23 = options.durationSeconds.unwrap(); + _option24 = 1; + _option25 = _payload23; + } else { + _option24 = 0; + _option25 = 0; + } + __import_banIp(this.__handle, _option4, _option5, _option10, _option11, _option12, _option17, _option18, _option19, _option24, _option25, cast(uint)(options.kickMatchingPlayers), cast(uint)(options.logToConsole)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.ban-ip") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.ban_ip") + static private extern(C) void __import_banIp(uint, uint, uint, uint, void*, size_t, uint, void*, size_t, uint, ulong, uint, uint) nothrow; + + /++ + Transfers the player to another server. + +/ + void transfer(in WitString host, ushort port) @trusted nothrow { + __import_transfer(this.__handle, cast(void*)(host.ptr), host.length, cast(uint)(port)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.transfer") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.transfer") + static private extern(C) void __import_transfer(uint, void*, size_t, uint) nothrow; + + /++ + Status Effects + Gives a status effect to the player. + +/ + void addEffect(in StatusEffectInstance effect) @trusted nothrow { + __import_addEffect(this.__handle, cast(uint)(effect.effectType), effect.duration, cast(uint)(effect.amplifier), cast(uint)(effect.ambient), cast(uint)(effect.showParticles), cast(uint)(effect.showIcon)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.add-effect") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.add_effect") + static private extern(C) void __import_addEffect(uint, uint, uint, uint, uint, uint, uint) nothrow; + + /++ + Removes a status effect from the player. + +/ + void removeEffect(StatusEffectType effect) @trusted nothrow { + __import_removeEffect(this.__handle, cast(uint)(effect)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.remove-effect") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.remove_effect") + static private extern(C) void __import_removeEffect(uint, uint) nothrow; + + /++ + Clears all active status effects from the player. + +/ + void clearEffects() @trusted nothrow { + __import_clearEffects(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.clear-effects") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.clear_effects") + static private extern(C) void __import_clearEffects(uint) nothrow; + + /++ + Checks if a status effect is currently applied to the player. + +/ + bool hasEffect(StatusEffectType effect) @trusted nothrow { + auto _ret = __import_hasEffect(this.__handle, cast(uint)(effect)); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.has-effect") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.has_effect") + static private extern(C) uint __import_hasEffect(uint, uint) nothrow; + + /++ + Returns the status effect instance applied to the player, if any. + +/ + Option!(StatusEffectInstance) getEffect(StatusEffectType effect) @trusted nothrow { + align(4) void[16] _retArea = void; + __import_getEffect(this.__handle, cast(uint)(effect), _retArea.ptr); + Option!(StatusEffectInstance) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + wit.pumpkin.plugin.status_effect.imports.StatusEffectInstance _record2 = { + effectType: cast(wit.pumpkin.plugin.status_effect.imports.StatusEffectType)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 4)))), + duration: *(cast(uint*)(_retArea.ptr + 8)), + amplifier: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 12)))), + ambient: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 13)))) != 0, + showParticles: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 14)))) != 0, + showIcon: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 15)))) != 0, + }; + + _option3 = Option!(StatusEffectInstance).makeSome(_record2); + } else { + _option3 = Option!(StatusEffectInstance).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-effect") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_effect") + static private extern(C) void __import_getEffect(uint, uint, void*) nothrow; + + /++ + Returns all status effects currently applied to the player. + +/ + WitList!(StatusEffectInstance) getActiveEffects() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getActiveEffects(this.__handle, _retArea.ptr); + auto _listSrcPtr2 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen2 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list2 = _listLen2 ? wit.common.mallocSlice!(StatusEffectInstance)(_listLen2) : []; + assert(!_listLen2 || _list2.ptr); + foreach (_elem0_idx, ref _elem0; _list2) { + const auto _base0 = _listSrcPtr2 + _elem0_idx * 12; + wit.pumpkin.plugin.status_effect.imports.StatusEffectInstance _record1 = { + effectType: cast(wit.pumpkin.plugin.status_effect.imports.StatusEffectType)(cast(uint)(*(cast(ubyte*)(_base0 + 0)))), + duration: *(cast(uint*)(_base0 + 4)), + amplifier: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base0 + 8)))), + ambient: (cast(uint)(*(cast(ubyte*)(_base0 + 9)))) != 0, + showParticles: (cast(uint)(*(cast(ubyte*)(_base0 + 10)))) != 0, + showIcon: (cast(uint)(*(cast(ubyte*)(_base0 + 11)))) != 0, + }; + _elem0 = _record1; + } + if (_listLen2) wit.common.free(_listSrcPtr2); + auto _witList3 = WitList!(StatusEffectInstance)(_list2); + auto _flush4 = _witList3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-active-effects") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_active_effects") + static private extern(C) void __import_getActiveEffects(uint, void*) nothrow; + + /++ + Health & Damage + Heals the player by a specified amount. + +/ + void heal(float amount) @trusted nothrow { + __import_heal(this.__handle, amount); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.heal") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.heal") + static private extern(C) void __import_heal(uint, float) nothrow; + + /++ + Deals damage to the player by a specified amount with a damage type. + +/ + void damage(float amount, DamageType damageType) @trusted nothrow { + __import_damage(this.__handle, amount, cast(uint)(damageType)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.damage") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.damage") + static private extern(C) void __import_damage(uint, float, uint) nothrow; + + /++ + Kills the player instantly. + +/ + void kill() @trusted nothrow { + __import_kill(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.kill") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.kill") + static private extern(C) void __import_kill(uint) nothrow; + + /++ + Statistics + Gets the value of a statistic for this player in the given category and ID. + +/ + int getStatistic(StatisticCategory category, int statId) @trusted nothrow { + auto _ret = __import_getStatistic(this.__handle, cast(uint)(category), cast(uint)(statId)); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-statistic") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_statistic") + static private extern(C) uint __import_getStatistic(uint, uint, uint) nothrow; + + /++ + Sets the value of a statistic for this player in the given category and ID. + +/ + void setStatistic(StatisticCategory category, int statId, int value) @trusted nothrow { + __import_setStatistic(this.__handle, cast(uint)(category), cast(uint)(statId), cast(uint)(value)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-statistic") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_statistic") + static private extern(C) void __import_setStatistic(uint, uint, uint, uint) nothrow; + + /++ + Increments the value of a statistic for this player in the given category and ID. + +/ + void incrementStatistic(StatisticCategory category, int statId, int amount) @trusted nothrow { + __import_incrementStatistic(this.__handle, cast(uint)(category), cast(uint)(statId), cast(uint)(amount)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.increment-statistic") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.increment_statistic") + static private extern(C) void __import_incrementStatistic(uint, uint, uint, uint) nothrow; + + /++ + Gets the value of a custom statistic for this player. + +/ + int getCustomStatistic(CustomStatistic stat) @trusted nothrow { + auto _ret = __import_getCustomStatistic(this.__handle, cast(uint)(stat)); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-custom-statistic") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_custom_statistic") + static private extern(C) uint __import_getCustomStatistic(uint, uint) nothrow; + + /++ + Sets the value of a custom statistic for this player. + +/ + void setCustomStatistic(CustomStatistic stat, int value) @trusted nothrow { + __import_setCustomStatistic(this.__handle, cast(uint)(stat), cast(uint)(value)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-custom-statistic") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_custom_statistic") + static private extern(C) void __import_setCustomStatistic(uint, uint, uint) nothrow; + + /++ + Increments the value of a custom statistic for this player. + +/ + void incrementCustomStatistic(CustomStatistic stat, int amount) @trusted nothrow { + __import_incrementCustomStatistic(this.__handle, cast(uint)(stat), cast(uint)(amount)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.increment-custom-statistic") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.increment_custom_statistic") + static private extern(C) void __import_incrementCustomStatistic(uint, uint, uint) nothrow; + + /++ + Sends the player's updated statistics packet to the client. + +/ + void sendStats() @trusted nothrow { + __import_sendStats(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.send-stats") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.send_stats") + static private extern(C) void __import_sendStats(uint) nothrow; + + /++ + Gets the team name that this player belongs to on their active scoreboard, if any. + +/ + Option!(WitString) getTeam() @trusted nothrow { + align(size_t.sizeof) void[(3*size_t.sizeof)] _retArea = void; + __import_getTeam(this.__handle, _retArea.ptr); + Option!(WitString) _option4 = void; + bool _isSome4 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome4) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + + _option4 = Option!(WitString).makeSome(_list3); + } else { + _option4 = Option!(WitString).makeNone; + } + auto _flush5 = _option4; + return _flush5; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-team") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_team") + static private extern(C) void __import_getTeam(uint, void*) nothrow; + + /++ + Cooldowns + Starts an item cooldown for a specific item group name. + +/ + void startCooldown(in WitString group, int durationTicks) @trusted nothrow { + __import_startCooldown(this.__handle, cast(void*)(group.ptr), group.length, cast(uint)(durationTicks)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.start-cooldown") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.start_cooldown") + static private extern(C) void __import_startCooldown(uint, void*, size_t, uint) nothrow; + + /++ + Returns the cooldown progress (0.0 to 1.0) for a specific item group. + +/ + float getCooldown(in WitString group) @trusted nothrow { + auto _ret = __import_getCooldown(this.__handle, cast(void*)(group.ptr), group.length); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-cooldown") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_cooldown") + static private extern(C) float __import_getCooldown(uint, void*, size_t) nothrow; + + /++ + Checks if a specific item group is currently on cooldown. + +/ + bool isOnCooldown(in WitString group) @trusted nothrow { + auto _ret = __import_isOnCooldown(this.__handle, cast(void*)(group.ptr), group.length); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.is-on-cooldown") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.is_on_cooldown") + static private extern(C) uint __import_isOnCooldown(uint, void*, size_t) nothrow; + + /++ + Abilities & Flight + Sets whether the player is allowed to fly. + +/ + void setAllowFlight(bool allowed) @trusted nothrow { + __import_setAllowFlight(this.__handle, cast(uint)(allowed)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-allow-flight") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_allow_flight") + static private extern(C) void __import_setAllowFlight(uint, uint) nothrow; + + /++ + Sets the player's flying speed. + +/ + void setFlySpeed(float speed) @trusted nothrow { + __import_setFlySpeed(this.__handle, speed); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-fly-speed") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_fly_speed") + static private extern(C) void __import_setFlySpeed(uint, float) nothrow; + + /++ + Sets the player's walking speed. + +/ + void setWalkSpeed(float speed) @trusted nothrow { + __import_setWalkSpeed(this.__handle, speed); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-walk-speed") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_walk_speed") + static private extern(C) void __import_setWalkSpeed(uint, float) nothrow; + + /++ + Sets whether the player is invulnerable to damage. + +/ + void setInvulnerable(bool invulnerable) @trusted nothrow { + __import_setInvulnerable(this.__handle, cast(uint)(invulnerable)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-invulnerable") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_invulnerable") + static private extern(C) void __import_setInvulnerable(uint, uint) nothrow; + + /++ + Inventory + Returns the player's inventory handle for managing main storage, armor, and equipment. + +/ + PlayerInventory getInventory() @trusted nothrow { + auto _ret = __import_getInventory(this.__handle); + auto _handle0 = PlayerInventory(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-inventory") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_inventory") + static private extern(C) uint __import_getInventory(uint) nothrow; + + /++ + Returns the player's ender chest inventory handle. + +/ + Inventory getEnderChest() @trusted nothrow { + auto _ret = __import_getEnderChest(this.__handle); + auto _handle0 = Inventory(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-ender-chest") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_ender_chest") + static private extern(C) uint __import_getEnderChest(uint) nothrow; + + /++ + Returns the index of the currently selected hotbar slot (0-8). + +/ + ubyte getSelectedSlot() @trusted nothrow { + auto _ret = __import_getSelectedSlot(this.__handle); + return cast(ubyte)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-selected-slot") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_selected_slot") + static private extern(C) uint __import_getSelectedSlot(uint) nothrow; + + /++ + Returns the item currently in the specified hand. + +/ + Option!(ItemStack) getItemInHand(Hand hand) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getItemInHand(this.__handle, cast(uint)(hand), _retArea.ptr); + Option!(ItemStack) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = ItemStack(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(ItemStack).makeSome(_handle2); + } else { + _option3 = Option!(ItemStack).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-item-in-hand") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_item_in_hand") + static private extern(C) void __import_getItemInHand(uint, uint, void*) nothrow; + + /++ + Returns the item in the specified inventory slot. + +/ + Option!(ItemStack) getInventoryItem(ubyte slot) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getInventoryItem(this.__handle, cast(uint)(slot), _retArea.ptr); + Option!(ItemStack) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = ItemStack(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(ItemStack).makeSome(_handle2); + } else { + _option3 = Option!(ItemStack).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-inventory-item") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_inventory_item") + static private extern(C) void __import_getInventoryItem(uint, uint, void*) nothrow; + + /++ + Sets the item in the specified hand. + +/ + void setItemInHand(Hand hand, in Option!(ItemStack) stack) @trusted nothrow { + uint _option4 = void; + uint _option5 = void; + if (stack.isSome) { + ref _payload3 = stack.unwrap(); + _option4 = 1; + _option5 = _payload3.__handle; + } else { + _option4 = 0; + _option5 = 0; + } + __import_setItemInHand(this.__handle, cast(uint)(hand), _option4, _option5); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-item-in-hand") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_item_in_hand") + static private extern(C) void __import_setItemInHand(uint, uint, uint, uint) nothrow; + + /++ + Sets the item in the specified inventory slot. + +/ + void setInventoryItem(ubyte slot, in Option!(ItemStack) stack) @trusted nothrow { + uint _option4 = void; + uint _option5 = void; + if (stack.isSome) { + ref _payload3 = stack.unwrap(); + _option4 = 1; + _option5 = _payload3.__handle; + } else { + _option4 = 0; + _option5 = 0; + } + __import_setInventoryItem(this.__handle, cast(uint)(slot), _option4, _option5); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-inventory-item") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_inventory_item") + static private extern(C) void __import_setInventoryItem(uint, uint, uint, uint) nothrow; + + /++ + Ender Chest Inventory + Returns the item in the specified ender chest slot (0-26). + +/ + Option!(ItemStack) getEnderChestItem(ubyte slot) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getEnderChestItem(this.__handle, cast(uint)(slot), _retArea.ptr); + Option!(ItemStack) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = ItemStack(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(ItemStack).makeSome(_handle2); + } else { + _option3 = Option!(ItemStack).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-ender-chest-item") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_ender_chest_item") + static private extern(C) void __import_getEnderChestItem(uint, uint, void*) nothrow; + + /++ + Sets the item in the specified ender chest slot (0-26). + +/ + void setEnderChestItem(ubyte slot, in Option!(ItemStack) stack) @trusted nothrow { + uint _option4 = void; + uint _option5 = void; + if (stack.isSome) { + ref _payload3 = stack.unwrap(); + _option4 = 1; + _option5 = _payload3.__handle; + } else { + _option4 = 0; + _option5 = 0; + } + __import_setEnderChestItem(this.__handle, cast(uint)(slot), _option4, _option5); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-ender-chest-item") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_ender_chest_item") + static private extern(C) void __import_setEnderChestItem(uint, uint, uint, uint) nothrow; + + /++ + Clears all items from the player's ender chest. + +/ + void clearEnderChest() @trusted nothrow { + __import_clearEnderChest(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.clear-ender-chest") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.clear_ender_chest") + static private extern(C) void __import_clearEnderChest(uint) nothrow; + + /++ + Opens the player's ender chest inventory screen for them. + +/ + void openEnderChest() @trusted nothrow { + __import_openEnderChest(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.open-ender-chest") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.open_ender_chest") + static private extern(C) void __import_openEnderChest(uint) nothrow; + + /++ + Status + Returns the player's current health. + +/ + float getHealth() @trusted nothrow { + auto _ret = __import_getHealth(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-health") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_health") + static private extern(C) float __import_getHealth(uint) nothrow; + + /++ + Sets the player's current health. + +/ + void setHealth(float health) @trusted nothrow { + __import_setHealth(this.__handle, health); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-health") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_health") + static private extern(C) void __import_setHealth(uint, float) nothrow; + + /++ + Returns the player's maximum health. + +/ + float getMaxHealth() @trusted nothrow { + auto _ret = __import_getMaxHealth(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-max-health") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_max_health") + static private extern(C) float __import_getMaxHealth(uint) nothrow; + + /++ + Sets the player's maximum health. + +/ + void setMaxHealth(float maxHealth) @trusted nothrow { + __import_setMaxHealth(this.__handle, maxHealth); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-max-health") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_max_health") + static private extern(C) void __import_setMaxHealth(uint, float) nothrow; + + /++ + Returns the player's food level (0-20). + +/ + ubyte getFoodLevel() @trusted nothrow { + auto _ret = __import_getFoodLevel(this.__handle); + return cast(ubyte)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-food-level") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_food_level") + static private extern(C) uint __import_getFoodLevel(uint) nothrow; + + /++ + Sets the player's food level. + +/ + void setFoodLevel(ubyte foodLevel) @trusted nothrow { + __import_setFoodLevel(this.__handle, cast(uint)(foodLevel)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-food-level") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_food_level") + static private extern(C) void __import_setFoodLevel(uint, uint) nothrow; + + /++ + Returns the player's food saturation level. + +/ + float getSaturation() @trusted nothrow { + auto _ret = __import_getSaturation(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-saturation") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_saturation") + static private extern(C) float __import_getSaturation(uint) nothrow; + + /++ + Sets the player's food saturation level. + +/ + void setSaturation(float saturation) @trusted nothrow { + __import_setSaturation(this.__handle, saturation); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-saturation") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_saturation") + static private extern(C) void __import_setSaturation(uint, float) nothrow; + + /++ + Returns the player's food exhaustion level. + +/ + float getExhaustion() @trusted nothrow { + auto _ret = __import_getExhaustion(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-exhaustion") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_exhaustion") + static private extern(C) float __import_getExhaustion(uint) nothrow; + + /++ + Sets the player's food exhaustion level. + +/ + void setExhaustion(float exhaustion) @trusted nothrow { + __import_setExhaustion(this.__handle, exhaustion); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-exhaustion") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_exhaustion") + static private extern(C) void __import_setExhaustion(uint, float) nothrow; + + /++ + Returns the player's current absorption amount. + +/ + float getAbsorption() @trusted nothrow { + auto _ret = __import_getAbsorption(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-absorption") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_absorption") + static private extern(C) float __import_getAbsorption(uint) nothrow; + + /++ + Sets the player's current absorption amount. + +/ + void setAbsorption(float absorption) @trusted nothrow { + __import_setAbsorption(this.__handle, absorption); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-absorption") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_absorption") + static private extern(C) void __import_setAbsorption(uint, float) nothrow; + + /++ + Returns the player's total experience level. + +/ + int getExperienceLevel() @trusted nothrow { + auto _ret = __import_getExperienceLevel(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-experience-level") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_experience_level") + static private extern(C) uint __import_getExperienceLevel(uint) nothrow; + + /++ + Returns the player's progress toward the next level (0.0 to 1.0). + +/ + float getExperienceProgress() @trusted nothrow { + auto _ret = __import_getExperienceProgress(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-experience-progress") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_experience_progress") + static private extern(C) float __import_getExperienceProgress(uint) nothrow; + + /++ + Returns the total experience points the player has. + +/ + int getExperiencePoints() @trusted nothrow { + auto _ret = __import_getExperiencePoints(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-experience-points") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_experience_points") + static private extern(C) uint __import_getExperiencePoints(uint) nothrow; + + /++ + Sets the player's total experience level. + +/ + void setExperienceLevel(int level) @trusted nothrow { + __import_setExperienceLevel(this.__handle, cast(uint)(level)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-experience-level") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_experience_level") + static private extern(C) void __import_setExperienceLevel(uint, uint) nothrow; + + /++ + Sets the player's progress toward the next level. + +/ + void setExperienceProgress(float progress) @trusted nothrow { + __import_setExperienceProgress(this.__handle, progress); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-experience-progress") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_experience_progress") + static private extern(C) void __import_setExperienceProgress(uint, float) nothrow; + + /++ + Sets the player's total experience points. + +/ + void setExperiencePoints(int points) @trusted nothrow { + __import_setExperiencePoints(this.__handle, cast(uint)(points)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-experience-points") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_experience_points") + static private extern(C) void __import_setExperiencePoints(uint, uint) nothrow; + + /++ + Adds experience levels to the player. + +/ + void addExperienceLevels(int levels) @trusted nothrow { + __import_addExperienceLevels(this.__handle, cast(uint)(levels)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.add-experience-levels") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.add_experience_levels") + static private extern(C) void __import_addExperienceLevels(uint, uint) nothrow; + + /++ + Adds experience points to the player. + +/ + void addExperiencePoints(int points) @trusted nothrow { + __import_addExperiencePoints(this.__handle, cast(uint)(points)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.add-experience-points") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.add_experience_points") + static private extern(C) void __import_addExperiencePoints(uint, uint) nothrow; + + /++ + Returns whether the player is currently flying. + +/ + bool isFlying() @trusted nothrow { + auto _ret = __import_isFlying(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.is-flying") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.is_flying") + static private extern(C) uint __import_isFlying(uint) nothrow; + + /++ + Sets whether the player should be flying. + +/ + void setFlying(bool flying) @trusted nothrow { + __import_setFlying(this.__handle, cast(uint)(flying)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-flying") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_flying") + static private extern(C) void __import_setFlying(uint, uint) nothrow; + + /++ + Returns the player's current abilities. + +/ + PlayerAbilities getAbilities() @trusted nothrow { + align(4) void[16] _retArea = void; + __import_getAbilities(this.__handle, _retArea.ptr); + PlayerAbilities _record0 = { + invulnerable: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0, + flying: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 1)))) != 0, + allowFlying: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 2)))) != 0, + creative: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 3)))) != 0, + allowModifyWorld: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 4)))) != 0, + flySpeed: *(cast(float*)(_retArea.ptr + 8)), + walkSpeed: *(cast(float*)(_retArea.ptr + 12)), + }; + auto _flush1 = _record0; + return _flush1; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-abilities") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_abilities") + static private extern(C) void __import_getAbilities(uint, void*) nothrow; + + /++ + Updates the player's abilities. + +/ + void setAbilities(in PlayerAbilities abilities) @trusted nothrow { + __import_setAbilities(this.__handle, cast(uint)(abilities.invulnerable), cast(uint)(abilities.flying), cast(uint)(abilities.allowFlying), cast(uint)(abilities.creative), cast(uint)(abilities.allowModifyWorld), abilities.flySpeed, abilities.walkSpeed); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-abilities") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_abilities") + static private extern(C) void __import_setAbilities(uint, uint, uint, uint, uint, uint, float, float) nothrow; + + /++ + Returns the player's IP address. + +/ + WitString getIp() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getIp(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-ip") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_ip") + static private extern(C) void __import_getIp(uint, void*) nothrow; + + /++ + Returns the player's current skin textures. + +/ + Option!(PlayerSkin) getSkin() @trusted nothrow { + align(size_t.sizeof) void[(6*size_t.sizeof)] _retArea = void; + __import_getSkin(this.__handle, _retArea.ptr); + Option!(PlayerSkin) _option10 = void; + bool _isSome10 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome10) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + Option!(WitString) _option8 = void; + bool _isSome8 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (3*size_t.sizeof))))) != 0; + if (_isSome8) { + auto _len6 = *(cast(size_t*)(_retArea.ptr + (5*size_t.sizeof))); + auto _ptr6 = _len6 ? cast(char*)(*(cast(void**)(_retArea.ptr + (4*size_t.sizeof)))) : null; + auto _list7 = WitString(_ptr6[0.._len6]); + + _option8 = Option!(WitString).makeSome(_list7); + } else { + _option8 = Option!(WitString).makeNone; + } + PlayerSkin _record9 = { + value: _list3, + signature: _option8, + }; + + _option10 = Option!(PlayerSkin).makeSome(_record9); + } else { + _option10 = Option!(PlayerSkin).makeNone; + } + auto _flush11 = _option10; + return _flush11; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-skin") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_skin") + static private extern(C) void __import_getSkin(uint, void*) nothrow; + + /++ + Updates the player's skin textures. + Note: this only updates the fields, it doesn't reload the skin. + +/ + void setSkin(in PlayerSkin skin) @trusted nothrow { + uint _option4 = void; + void* _option5 = void; + size_t _option6 = void; + if (skin.signature.isSome) { + ref _payload3 = skin.signature.unwrap(); + _option4 = 1; + _option5 = cast(void*)(_payload3.ptr); + _option6 = _payload3.length; + } else { + _option4 = 0; + _option5 = null; + _option6 = 0; + } + __import_setSkin(this.__handle, cast(void*)(skin.value.ptr), skin.value.length, _option4, _option5, _option6); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-skin") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_skin") + static private extern(C) void __import_setSkin(uint, void*, size_t, uint, void*, size_t) nothrow; + + /++ + Returns which skin parts are visible. + +/ + SkinParts getSkinParts() @trusted nothrow { + auto _ret = __import_getSkinParts(this.__handle); + return SkinParts(cast(ubyte)(_ret)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-skin-parts") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_skin_parts") + static private extern(C) uint __import_getSkinParts(uint) nothrow; + + /++ + Sets which skin parts are visible. + +/ + void setSkinParts(SkinParts parts) @trusted nothrow { + __import_setSkinParts(this.__handle, cast(uint)(parts.bits)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-skin-parts") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_skin_parts") + static private extern(C) void __import_setSkinParts(uint, uint) nothrow; + + /++ + Per-Player Environment & Overrides + Overrides the time of day shown to this player. + +/ + void setPlayerTime(ulong time, bool relative) @trusted nothrow { + __import_setPlayerTime(this.__handle, time, cast(uint)(relative)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-player-time") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_player_time") + static private extern(C) void __import_setPlayerTime(uint, ulong, uint) nothrow; + + /++ + Resets the player's time to sync with the server world time. + +/ + void resetPlayerTime() @trusted nothrow { + __import_resetPlayerTime(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.reset-player-time") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.reset_player_time") + static private extern(C) void __import_resetPlayerTime(uint) nothrow; + + /++ + Returns the custom time set for this player, if any. + +/ + Option!(ulong) getPlayerTime() @trusted nothrow { + align(8) void[16] _retArea = void; + __import_getPlayerTime(this.__handle, _retArea.ptr); + Option!(ulong) _option2 = void; + bool _isSome2 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome2) { + + _option2 = Option!(ulong).makeSome(*(cast(ulong*)(_retArea.ptr + 8))); + } else { + _option2 = Option!(ulong).makeNone; + } + auto _flush3 = _option2; + return _flush3; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-player-time") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_player_time") + static private extern(C) void __import_getPlayerTime(uint, void*) nothrow; + + /++ + Checks if the custom player time is relative to the world time. + +/ + bool isPlayerTimeRelative() @trusted nothrow { + auto _ret = __import_isPlayerTimeRelative(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.is-player-time-relative") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.is_player_time_relative") + static private extern(C) uint __import_isPlayerTimeRelative(uint) nothrow; + + /++ + Overrides the weather condition shown to this player. + +/ + void setPlayerWeather(PlayerWeather weather) @trusted nothrow { + __import_setPlayerWeather(this.__handle, cast(uint)(weather)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-player-weather") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_player_weather") + static private extern(C) void __import_setPlayerWeather(uint, uint) nothrow; + + /++ + Resets the player's weather to match the server world weather. + +/ + void resetPlayerWeather() @trusted nothrow { + __import_resetPlayerWeather(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.reset-player-weather") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.reset_player_weather") + static private extern(C) void __import_resetPlayerWeather(uint) nothrow; + + /++ + Returns the custom weather set for this player, if any. + +/ + Option!(PlayerWeather) getPlayerWeather() @trusted nothrow { + align(1) void[2] _retArea = void; + __import_getPlayerWeather(this.__handle, _retArea.ptr); + Option!(PlayerWeather) _option2 = void; + bool _isSome2 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome2) { + + _option2 = Option!(PlayerWeather).makeSome(cast(PlayerWeather)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 1))))); + } else { + _option2 = Option!(PlayerWeather).makeNone; + } + auto _flush3 = _option2; + return _flush3; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-player-weather") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_player_weather") + static private extern(C) void __import_getPlayerWeather(uint, void*) nothrow; + + /++ + Sets the position where the player's compass points. + +/ + void setCompassTarget(in Position pos) @trusted nothrow { + __import_setCompassTarget(this.__handle, pos[0], pos[1], pos[2]); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-compass-target") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_compass_target") + static private extern(C) void __import_setCompassTarget(uint, double, double, double) nothrow; + + /++ + Returns the position where the player's compass currently points. + +/ + Position getCompassTarget() @trusted nothrow { + align(8) void[24] _retArea = void; + __import_getCompassTarget(this.__handle, _retArea.ptr); + auto _tuple0 = wit.pumpkin.plugin.common.imports.Position( + *(cast(double*)(_retArea.ptr + 0)), + *(cast(double*)(_retArea.ptr + 8)), + *(cast(double*)(_retArea.ptr + 16)), + ); + auto _flush1 = _tuple0; + return _flush1; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-compass-target") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_compass_target") + static private extern(C) void __import_getCompassTarget(uint, void*) nothrow; + + /++ + Sets the player's custom respawn / bed location. + +/ + void setRespawnLocation(in Position pos) @trusted nothrow { + __import_setRespawnLocation(this.__handle, pos[0], pos[1], pos[2]); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-respawn-location") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_respawn_location") + static private extern(C) void __import_setRespawnLocation(uint, double, double, double) nothrow; + + /++ + Returns the player's custom respawn / bed location, if set. + +/ + Option!(Position) getRespawnLocation() @trusted nothrow { + align(8) void[32] _retArea = void; + __import_getRespawnLocation(this.__handle, _retArea.ptr); + Option!(Position) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _tuple2 = wit.pumpkin.plugin.common.imports.Position( + *(cast(double*)(_retArea.ptr + 8)), + *(cast(double*)(_retArea.ptr + 16)), + *(cast(double*)(_retArea.ptr + 24)), + ); + + _option3 = Option!(Position).makeSome(_tuple2); + } else { + _option3 = Option!(Position).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-respawn-location") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_respawn_location") + static private extern(C) void __import_getRespawnLocation(uint, void*) nothrow; + + /++ + Hides another player from this player's view (vanish). + +/ + void hidePlayer(Player other) @trusted nothrow { + __import_hidePlayer(this.__handle, other.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.hide-player") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.hide_player") + static private extern(C) void __import_hidePlayer(uint, uint) nothrow; + + /++ + Shows a previously hidden player to this player. + +/ + void showPlayer(Player other) @trusted nothrow { + __import_showPlayer(this.__handle, other.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.show-player") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.show_player") + static private extern(C) void __import_showPlayer(uint, uint) nothrow; + + /++ + Checks if this player can see another specified player. + +/ + bool canSee(Player other) @trusted nothrow { + auto _ret = __import_canSee(this.__handle, other.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.can-see") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.can_see") + static private extern(C) uint __import_canSee(uint, uint) nothrow; + + /++ + Checks if this player can see another specified player. + +/ + bool canSeePlayer(Player other) @trusted nothrow { + auto _ret = __import_canSeePlayer(this.__handle, other.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.can-see-player") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.can_see_player") + static private extern(C) uint __import_canSeePlayer(uint, uint) nothrow; + + /++ + Sets the tab list ping / latency indicator in milliseconds. + +/ + void setTabListPing(int latencyMs) @trusted nothrow { + __import_setTabListPing(this.__handle, cast(uint)(latencyMs)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-tab-list-ping") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_tab_list_ping") + static private extern(C) void __import_setTabListPing(uint, uint) nothrow; + + /++ + Sets a client-side item cooldown overlay. + +/ + void setItemCooldown(in WitString itemId, int ticks) @trusted nothrow { + __import_setItemCooldown(this.__handle, cast(void*)(itemId.ptr), itemId.length, cast(uint)(ticks)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-item-cooldown") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_item_cooldown") + static private extern(C) void __import_setItemCooldown(uint, void*, size_t, uint) nothrow; + + /++ + Returns the remaining cooldown ticks for an item, if active. + +/ + Option!(int) getItemCooldown(in WitString itemId) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getItemCooldown(this.__handle, cast(void*)(itemId.ptr), itemId.length, _retArea.ptr); + Option!(int) _option2 = void; + bool _isSome2 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome2) { + + _option2 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_retArea.ptr + 4)))); + } else { + _option2 = Option!(int).makeNone; + } + auto _flush3 = _option2; + return _flush3; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-item-cooldown") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_item_cooldown") + static private extern(C) void __import_getItemCooldown(uint, void*, size_t, void*) nothrow; + + /++ + Checks if an item is currently on cooldown. + +/ + bool hasItemCooldown(in WitString itemId) @trusted nothrow { + auto _ret = __import_hasItemCooldown(this.__handle, cast(void*)(itemId.ptr), itemId.length); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.has-item-cooldown") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.has_item_cooldown") + static private extern(C) uint __import_hasItemCooldown(uint, void*, size_t) nothrow; + + /++ + Performs a ray-trace from the player's eye position in looking direction to find the targeted block. + +/ + Option!(RayTraceBlockResult) rayTraceBlock(double maxDistance, bool includeFluids) @trusted nothrow { + align(8) void[48] _retArea = void; + __import_rayTraceBlock(this.__handle, maxDistance, cast(uint)(includeFluids), _retArea.ptr); + Option!(RayTraceBlockResult) _option5 = void; + bool _isSome5 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome5) { + wit.pumpkin.plugin.common.imports.BlockPos _record2 = { + x: cast(int)(*(cast(uint*)(_retArea.ptr + 8))), + y: cast(int)(*(cast(uint*)(_retArea.ptr + 12))), + z: cast(int)(*(cast(uint*)(_retArea.ptr + 16))), + }; + auto _tuple3 = wit.pumpkin.plugin.common.imports.Position( + *(cast(double*)(_retArea.ptr + 24)), + *(cast(double*)(_retArea.ptr + 32)), + *(cast(double*)(_retArea.ptr + 40)), + ); + wit.pumpkin.plugin.world.imports.RayTraceBlockResult _record4 = { + pos: _record2, + face: cast(wit.pumpkin.plugin.world.imports.BlockDirection)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 20)))), + hitPos: _tuple3, + }; + + _option5 = Option!(RayTraceBlockResult).makeSome(_record4); + } else { + _option5 = Option!(RayTraceBlockResult).makeNone; + } + auto _flush6 = _option5; + return _flush6; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.ray-trace-block") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.ray_trace_block") + static private extern(C) void __import_rayTraceBlock(uint, double, uint, void*) nothrow; + + /++ + Performs a ray-trace from the player's eye position in looking direction to find the targeted entity. + +/ + Option!(RayTraceEntityResult) rayTraceEntity(double maxDistance) @trusted nothrow { + align(8) void[48] _retArea = void; + __import_rayTraceEntity(this.__handle, maxDistance, _retArea.ptr); + Option!(RayTraceEntityResult) _option5 = void; + bool _isSome5 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome5) { + auto _handle2 = wit.pumpkin.plugin.world.imports.Entity(*(cast(uint*)(_retArea.ptr + 8))); + auto _tuple3 = wit.pumpkin.plugin.common.imports.Position( + *(cast(double*)(_retArea.ptr + 16)), + *(cast(double*)(_retArea.ptr + 24)), + *(cast(double*)(_retArea.ptr + 32)), + ); + wit.pumpkin.plugin.world.imports.RayTraceEntityResult _record4 = { + entity: _handle2, + hitPos: _tuple3, + distance: *(cast(double*)(_retArea.ptr + 40)), + }; + + _option5 = Option!(RayTraceEntityResult).makeSome(_record4); + } else { + _option5 = Option!(RayTraceEntityResult).makeNone; + } + auto _flush6 = _option5; + return _flush6; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.ray-trace-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.ray_trace_entity") + static private extern(C) void __import_rayTraceEntity(uint, double, void*) nothrow; + + /++ + Returns the entity currently targeted in the looking direction within the specified distance. + +/ + Option!(Entity) getTargetEntity(double maxDistance) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getTargetEntity(this.__handle, maxDistance, _retArea.ptr); + Option!(Entity) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = Entity(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(Entity).makeSome(_handle2); + } else { + _option3 = Option!(Entity).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-target-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_target_entity") + static private extern(C) void __import_getTargetEntity(uint, double, void*) nothrow; + + /++ + Raycasts from the player's eyes to find the block being targeted. + +/ + Option!(Position) getTargetBlock(uint maxDistance) @trusted nothrow { + align(8) void[32] _retArea = void; + __import_getTargetBlock(this.__handle, maxDistance, _retArea.ptr); + Option!(Position) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _tuple2 = wit.pumpkin.plugin.common.imports.Position( + *(cast(double*)(_retArea.ptr + 8)), + *(cast(double*)(_retArea.ptr + 16)), + *(cast(double*)(_retArea.ptr + 24)), + ); + + _option3 = Option!(Position).makeSome(_tuple2); + } else { + _option3 = Option!(Position).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-target-block") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_target_block") + static private extern(C) void __import_getTargetBlock(uint, uint, void*) nothrow; + + /++ + Performs a raycast from the player's eyes to find the exact block and face being targeted. + +/ + Option!(RayTraceBlockResult) getTargetBlockExact(double maxDistance, bool includeFluids) @trusted nothrow { + align(8) void[48] _retArea = void; + __import_getTargetBlockExact(this.__handle, maxDistance, cast(uint)(includeFluids), _retArea.ptr); + Option!(RayTraceBlockResult) _option5 = void; + bool _isSome5 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome5) { + wit.pumpkin.plugin.common.imports.BlockPos _record2 = { + x: cast(int)(*(cast(uint*)(_retArea.ptr + 8))), + y: cast(int)(*(cast(uint*)(_retArea.ptr + 12))), + z: cast(int)(*(cast(uint*)(_retArea.ptr + 16))), + }; + auto _tuple3 = wit.pumpkin.plugin.common.imports.Position( + *(cast(double*)(_retArea.ptr + 24)), + *(cast(double*)(_retArea.ptr + 32)), + *(cast(double*)(_retArea.ptr + 40)), + ); + wit.pumpkin.plugin.world.imports.RayTraceBlockResult _record4 = { + pos: _record2, + face: cast(wit.pumpkin.plugin.world.imports.BlockDirection)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 20)))), + hitPos: _tuple3, + }; + + _option5 = Option!(RayTraceBlockResult).makeSome(_record4); + } else { + _option5 = Option!(RayTraceBlockResult).makeNone; + } + auto _flush6 = _option5; + return _flush6; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-target-block-exact") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_target_block_exact") + static private extern(C) void __import_getTargetBlockExact(uint, double, uint, void*) nothrow; + + /++ + Launches a projectile from the player's eyes in their line of sight. + +/ + Option!(Entity) launchProjectile(ProjectileType type) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_launchProjectile(this.__handle, cast(uint)(type), _retArea.ptr); + Option!(Entity) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = Entity(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(Entity).makeSome(_handle2); + } else { + _option3 = Option!(Entity).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.launch-projectile") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.launch_projectile") + static private extern(C) void __import_launchProjectile(uint, uint, void*) nothrow; + + /++ + Advancements + Returns the progress of the specified advancement for this player, if the advancement exists. + +/ + Option!(AdvancementProgress) getAdvancementProgress(in WitString advancementId) @trusted nothrow { + align(size_t.sizeof) void[(8*size_t.sizeof)] _retArea = void; + __import_getAdvancementProgress(this.__handle, cast(void*)(advancementId.ptr), advancementId.length, _retArea.ptr); + Option!(AdvancementProgress) _option15 = void; + bool _isSome15 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome15) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + auto _listSrcPtr7 = *(cast(void**)(_retArea.ptr + (4*size_t.sizeof))); + auto _listLen7 = *(cast(size_t*)(_retArea.ptr + (5*size_t.sizeof))); + auto _list7 = _listLen7 ? wit.common.mallocSlice!(WitString)(_listLen7) : []; + assert(!_listLen7 || _list7.ptr); + foreach (_elem4_idx, ref _elem4; _list7) { + const auto _base4 = _listSrcPtr7 + _elem4_idx * (2*size_t.sizeof); + auto _len5 = *(cast(size_t*)(_base4 + size_t.sizeof)); + auto _ptr5 = _len5 ? cast(char*)(*(cast(void**)(_base4 + 0))) : null; + auto _list6 = WitString(_ptr5[0.._len5]); + _elem4 = _list6; + } + if (_listLen7) wit.common.free(_listSrcPtr7); + auto _witList8 = WitList!(WitString)(_list7); + auto _listSrcPtr12 = *(cast(void**)(_retArea.ptr + (6*size_t.sizeof))); + auto _listLen12 = *(cast(size_t*)(_retArea.ptr + (7*size_t.sizeof))); + auto _list12 = _listLen12 ? wit.common.mallocSlice!(WitString)(_listLen12) : []; + assert(!_listLen12 || _list12.ptr); + foreach (_elem9_idx, ref _elem9; _list12) { + const auto _base9 = _listSrcPtr12 + _elem9_idx * (2*size_t.sizeof); + auto _len10 = *(cast(size_t*)(_base9 + size_t.sizeof)); + auto _ptr10 = _len10 ? cast(char*)(*(cast(void**)(_base9 + 0))) : null; + auto _list11 = WitString(_ptr10[0.._len10]); + _elem9 = _list11; + } + if (_listLen12) wit.common.free(_listSrcPtr12); + auto _witList13 = WitList!(WitString)(_list12); + wit.pumpkin.plugin.advancement.imports.AdvancementProgress _record14 = { + advancementId: _list3, + done: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (3*size_t.sizeof))))) != 0, + awardedCriteria: _witList8, + remainingCriteria: _witList13, + }; + + _option15 = Option!(AdvancementProgress).makeSome(_record14); + } else { + _option15 = Option!(AdvancementProgress).makeNone; + } + auto _flush16 = _option15; + return _flush16; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-advancement-progress") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_advancement_progress") + static private extern(C) void __import_getAdvancementProgress(uint, void*, size_t, void*) nothrow; + + /++ + Awards a specific criterion of an advancement to the player. + Returns true if the criterion was successfully awarded (was not already completed). + +/ + bool awardAdvancementCriterion(in WitString advancementId, in WitString criterion) @trusted nothrow { + auto _ret = __import_awardAdvancementCriterion(this.__handle, cast(void*)(advancementId.ptr), advancementId.length, cast(void*)(criterion.ptr), criterion.length); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.award-advancement-criterion") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.award_advancement_criterion") + static private extern(C) uint __import_awardAdvancementCriterion(uint, void*, size_t, void*, size_t) nothrow; + + /++ + Revokes a specific criterion of an advancement from the player. + Returns true if the criterion was successfully revoked (was previously completed). + +/ + bool revokeAdvancementCriterion(in WitString advancementId, in WitString criterion) @trusted nothrow { + auto _ret = __import_revokeAdvancementCriterion(this.__handle, cast(void*)(advancementId.ptr), advancementId.length, cast(void*)(criterion.ptr), criterion.length); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.revoke-advancement-criterion") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.revoke_advancement_criterion") + static private extern(C) uint __import_revokeAdvancementCriterion(uint, void*, size_t, void*, size_t) nothrow; + + /++ + Awards all criteria of the specified advancement to the player. + Returns true if any criterion was newly awarded. + +/ + bool awardAdvancement(in WitString advancementId) @trusted nothrow { + auto _ret = __import_awardAdvancement(this.__handle, cast(void*)(advancementId.ptr), advancementId.length); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.award-advancement") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.award_advancement") + static private extern(C) uint __import_awardAdvancement(uint, void*, size_t) nothrow; + + /++ + Revokes all criteria of the specified advancement from the player. + Returns true if any criterion was newly revoked. + +/ + bool revokeAdvancement(in WitString advancementId) @trusted nothrow { + auto _ret = __import_revokeAdvancement(this.__handle, cast(void*)(advancementId.ptr), advancementId.length); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.revoke-advancement") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.revoke_advancement") + static private extern(C) uint __import_revokeAdvancement(uint, void*, size_t) nothrow; + + /++ + Checks whether the player has completed the specified advancement. + +/ + bool hasAdvancement(in WitString advancementId) @trusted nothrow { + auto _ret = __import_hasAdvancement(this.__handle, cast(void*)(advancementId.ptr), advancementId.length); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.has-advancement") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.has_advancement") + static private extern(C) uint __import_hasAdvancement(uint, void*, size_t) nothrow; + + /++ + Returns a list of all advancement IDs completed by this player. + +/ + WitList!(WitString) getCompletedAdvancements() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getCompletedAdvancements(this.__handle, _retArea.ptr); + auto _listSrcPtr3 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen3 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list3 = _listLen3 ? wit.common.mallocSlice!(WitString)(_listLen3) : []; + assert(!_listLen3 || _list3.ptr); + foreach (_elem0_idx, ref _elem0; _list3) { + const auto _base0 = _listSrcPtr3 + _elem0_idx * (2*size_t.sizeof); + auto _len1 = *(cast(size_t*)(_base0 + size_t.sizeof)); + auto _ptr1 = _len1 ? cast(char*)(*(cast(void**)(_base0 + 0))) : null; + auto _list2 = WitString(_ptr1[0.._len1]); + _elem0 = _list2; + } + if (_listLen3) wit.common.free(_listSrcPtr3); + auto _witList4 = WitList!(WitString)(_list3); + auto _flush5 = _witList4; + return _flush5; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-completed-advancements") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_completed_advancements") + static private extern(C) void __import_getCompletedAdvancements(uint, void*) nothrow; + + /++ + Returns the ID of the currently selected advancement tab for this player, if any. + +/ + Option!(WitString) getSelectedAdvancementTab() @trusted nothrow { + align(size_t.sizeof) void[(3*size_t.sizeof)] _retArea = void; + __import_getSelectedAdvancementTab(this.__handle, _retArea.ptr); + Option!(WitString) _option4 = void; + bool _isSome4 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome4) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + + _option4 = Option!(WitString).makeSome(_list3); + } else { + _option4 = Option!(WitString).makeNone; + } + auto _flush5 = _option4; + return _flush5; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.get-selected-advancement-tab") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.get_selected_advancement_tab") + static private extern(C) void __import_getSelectedAdvancementTab(uint, void*) nothrow; + + /++ + Sets the selected advancement tab for this player (must be a root advancement ID). + +/ + void setSelectedAdvancementTab(in Option!(WitString) tabId) @trusted nothrow { + uint _option4 = void; + void* _option5 = void; + size_t _option6 = void; + if (tabId.isSome) { + ref _payload3 = tabId.unwrap(); + _option4 = 1; + _option5 = cast(void*)(_payload3.ptr); + _option6 = _payload3.length; + } else { + _option4 = 0; + _option5 = null; + _option6 = 0; + } + __import_setSelectedAdvancementTab(this.__handle, _option4, _option5, _option6); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.set-selected-advancement-tab") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.set_selected_advancement_tab") + static private extern(C) void __import_setSelectedAdvancementTab(uint, uint, void*, size_t) nothrow; + + /++ + Returns a Java-specific player handle, if the player is connected via Java Edition. + + This allows access to Java-exclusive features like sending specific packets + or retrieving the client brand. + +/ + Option!(JavaPlayer) asJava() @trusted nothrow { + align(4) void[8] _retArea = void; + __import_asJava(this.__handle, _retArea.ptr); + Option!(JavaPlayer) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = JavaPlayer(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(JavaPlayer).makeSome(_handle2); + } else { + _option3 = Option!(JavaPlayer).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.as-java") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.as_java") + static private extern(C) void __import_asJava(uint, void*) nothrow; + + /++ + Returns a Bedrock-specific player handle, if the player is connected via Bedrock Edition. + + This allows access to Bedrock-exclusive features like custom forms + or detailed device information. + +/ + Option!(BedrockPlayer) asBedrock() @trusted nothrow { + align(4) void[8] _retArea = void; + __import_asBedrock(this.__handle, _retArea.ptr); + Option!(BedrockPlayer) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = BedrockPlayer(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(BedrockPlayer).makeSome(_handle2); + } else { + _option3 = Option!(BedrockPlayer).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]player.as-bedrock") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:player.as_bedrock") + static private extern(C) void __import_asBedrock(uint, void*) nothrow; + } +} + +/++ +Represents a resource pack sent to a Java Edition player. ++/ +struct JavaResourcePack { + /++ + Unique identifier for the resource pack. + +/ + Uuid id; + + /++ + The URL to the resource pack file. + +/ + WitString url; + + /++ + The SHA1 hash (40-character hex string) of the pack. + +/ + WitString hash; + + /++ + Whether the player is forced to accept the pack. + +/ + bool forced; + + /++ + Optional prompt message displayed in the pack acceptance screen. + +/ + Option!(TextComponent) promptMessage; + + void witFree() @nogc nothrow { + url.witFree; + hash.witFree; + } + + void witDrop() @nogc nothrow { + promptMessage.witDrop; + } + + JavaResourcePack witClone() const @nogc nothrow { + JavaResourcePack clone = void; + clone.id = this.id.witClone; + clone.url = this.url.witClone; + clone.hash = this.hash.witClone; + clone.forced = this.forced.witClone; + clone.promptMessage = this.promptMessage.witClone; + return clone; + } +} + +/++ +A handle to a player connected via the Java Edition. ++/ +struct JavaPlayer { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/player@0.1.0", "[resource-drop]java-player") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:resource_drop:java_player") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + Returns the Minecraft Java Edition version of the player. + +/ + JavaMinecraftVersion getVersion() @trusted nothrow { + auto _ret = __import_getVersion(this.__handle); + return cast(JavaMinecraftVersion)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]java-player.get-version") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:java_player.get_version") + static private extern(C) uint __import_getVersion(uint) nothrow; + + /++ + Returns the brand of the player's client (e.g., \"vanilla\", \"fabric\"). + +/ + WitString getBrand() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getBrand(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]java-player.get-brand") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:java_player.get_brand") + static private extern(C) void __import_getBrand(uint, void*) nothrow; + + /++ + Returns the server address the player used to connect. + +/ + WitString getServerAddress() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getServerAddress(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]java-player.get-server-address") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:java_player.get_server_address") + static private extern(C) void __import_getServerAddress(uint, void*) nothrow; + + /++ + Returns the player's configuration settings. + +/ + JavaPlayerSettings getSettings() @trusted nothrow { + align(size_t.sizeof) void[(8+2*size_t.sizeof)] _retArea = void; + __import_getSettings(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + JavaPlayerSettings _record2 = { + locale: _list1, + viewDistance: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (2*size_t.sizeof))))), + chatMode: cast(ChatMode)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (1+2*size_t.sizeof))))), + chatColors: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (2+2*size_t.sizeof))))) != 0, + skinParts: SkinParts(cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (3+2*size_t.sizeof)))))), + mainHand: cast(wit.pumpkin.plugin.common.imports.Hand)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (4+2*size_t.sizeof))))), + textFiltering: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (5+2*size_t.sizeof))))) != 0, + serverListing: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (6+2*size_t.sizeof))))) != 0, + }; + auto _flush3 = _record2; + return _flush3; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]java-player.get-settings") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:java_player.get_settings") + static private extern(C) void __import_getSettings(uint, void*) nothrow; + + /++ + Sends a Java-specific clientbound packet to the player. + +/ + void sendPacket(in JavaPacket packet) @trusted nothrow { + align(8) void[(56+20*size_t.sizeof)] _retArea = void; + wit.common.DeallocateBuffer deallocate; + *cast(uint*)(_retArea.ptr + 0) = cast(uint)(this.__handle); + alias _Tag752 = wit.pumpkin.plugin.java_packets.imports.ClientboundPacket.Tag; + final switch (packet.tag) { + case _Tag752.configCConfigAddResourcePack: { + const ref wit.pumpkin.plugin.java_packets.imports.ConfigCConfigAddResourcePack _payload1 = packet.getConfigCConfigAddResourcePack(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(0); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(_payload1.uuid.high); + *cast(ulong*)(_retArea.ptr + 24) = cast(ulong)(_payload1.uuid.low); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload1.url.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload1.url.ptr)); + *cast(size_t*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(size_t)(_payload1.hash.length); + *cast(void**)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload1.hash.ptr)); + *cast(ubyte*)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload1.forced)); + if (_payload1.promptMessage.isSome) { + ref _payload5 = _payload1.promptMessage.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+5*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+7*size_t.sizeof)) = cast(size_t)(_payload5.length); + *cast(void**)(_retArea.ptr + (32+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (32+5*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag752.configCConfigClearDialog: { + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(1); + break; + } + case _Tag752.configCCodeOfConduct: { + const ref wit.pumpkin.plugin.java_packets.imports.ConfigCCodeOfConduct _payload9 = packet.getConfigCCodeOfConduct(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(2); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload9.codeOfConduct.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload9.codeOfConduct.ptr)); + break; + } + case _Tag752.configCConfigDisconnect: { + const ref wit.pumpkin.plugin.java_packets.imports.ConfigCConfigDisconnect _payload11 = packet.getConfigCConfigDisconnect(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(3); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload11.reason.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload11.reason.ptr)); + break; + } + case _Tag752.configCCookieRequest: { + const ref wit.pumpkin.plugin.java_packets.imports.ConfigCCookieRequest _payload13 = packet.getConfigCCookieRequest(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(4); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload13.key.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload13.key.ptr)); + break; + } + case _Tag752.configCConfigCustomReportDetails: { + const ref wit.pumpkin.plugin.java_packets.imports.ConfigCConfigCustomReportDetails _payload15 = packet.getConfigCConfigCustomReportDetails(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(5); + auto _listSrc17 = _payload15.details; + auto _list17 = _listSrc17.length ? wit.common.malloc(_listSrc17.length * ((4*size_t.sizeof))) : null; + assert(!_listSrc17.length || _list17); + if (_listSrc17.length) deallocate ~= _list17; + foreach (_elem16_idx, ref _elem16; _listSrc17) { + auto _base16 = _list17 + _elem16_idx * ((4*size_t.sizeof)); + *cast(size_t*)(_base16 + size_t.sizeof) = cast(size_t)(_elem16[0].length); + *cast(void**)(_base16 + 0) = cast(void*)(cast(void*)(_elem16[0].ptr)); + *cast(size_t*)(_base16 + (3*size_t.sizeof)) = cast(size_t)(_elem16[1].length); + *cast(void**)(_base16 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem16[1].ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload15.details.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(_list17); + break; + } + case _Tag752.configCFeatureFlags: { + const ref wit.pumpkin.plugin.java_packets.imports.ConfigCFeatureFlags _payload19 = packet.getConfigCFeatureFlags(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(6); + auto _listSrc21 = _payload19.features; + auto _list21 = _listSrc21.length ? wit.common.malloc(_listSrc21.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc21.length || _list21); + if (_listSrc21.length) deallocate ~= _list21; + foreach (_elem20_idx, ref _elem20; _listSrc21) { + auto _base20 = _list21 + _elem20_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base20 + size_t.sizeof) = cast(size_t)(_elem20.length); + *cast(void**)(_base20 + 0) = cast(void*)(cast(void*)(_elem20.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload19.features.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(_list21); + break; + } + case _Tag752.configCFinishConfig: { + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(7); + break; + } + case _Tag752.configCKnownPacks: { + const ref wit.pumpkin.plugin.java_packets.imports.ConfigCKnownPacks _payload25 = packet.getConfigCKnownPacks(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(8); + auto _listSrc27 = _payload25.knownPacks; + auto _list27 = _listSrc27.length ? wit.common.malloc(_listSrc27.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc27.length || _list27); + if (_listSrc27.length) deallocate ~= _list27; + foreach (_elem26_idx, ref _elem26; _listSrc27) { + auto _base26 = _list27 + _elem26_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base26 + size_t.sizeof) = cast(size_t)(_elem26.length); + *cast(void**)(_base26 + 0) = cast(void*)(cast(void*)(_elem26.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload25.knownPacks.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(_list27); + break; + } + case _Tag752.configCConfigPing: { + const ref wit.pumpkin.plugin.java_packets.imports.ConfigCConfigPing _payload29 = packet.getConfigCConfigPing(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(9); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload29.id)); + break; + } + case _Tag752.configCPluginMessage: { + const ref wit.pumpkin.plugin.java_packets.imports.ConfigCPluginMessage _payload31 = packet.getConfigCPluginMessage(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(10); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload31.channel.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload31.channel.ptr)); + *cast(size_t*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(size_t)(_payload31.data.length); + *cast(void**)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload31.data.ptr)); + break; + } + case _Tag752.configCRegistryData: { + const ref wit.pumpkin.plugin.java_packets.imports.ConfigCRegistryData _payload33 = packet.getConfigCRegistryData(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(11); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload33.registryId.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload33.registryId.ptr)); + auto _listSrc35 = _payload33.entries; + auto _list35 = _listSrc35.length ? wit.common.malloc(_listSrc35.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc35.length || _list35); + if (_listSrc35.length) deallocate ~= _list35; + foreach (_elem34_idx, ref _elem34; _listSrc35) { + auto _base34 = _list35 + _elem34_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base34 + size_t.sizeof) = cast(size_t)(_elem34.length); + *cast(void**)(_base34 + 0) = cast(void*)(cast(void*)(_elem34.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(size_t)(_payload33.entries.length); + *cast(void**)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(void*)(_list35); + break; + } + case _Tag752.configCConfigRemoveResourcePack: { + const ref wit.pumpkin.plugin.java_packets.imports.ConfigCConfigRemoveResourcePack _payload37 = packet.getConfigCConfigRemoveResourcePack(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(12); + if (_payload37.uuid.isSome) { + ref _payload41 = _payload37.uuid.unwrap(); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(1); + *cast(ulong*)(_retArea.ptr + 24) = cast(ulong)(_payload41.high); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(_payload41.low); + } else { + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(0); + } + break; + } + case _Tag752.configCConfigResetChat: { + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(13); + break; + } + case _Tag752.configCConfigServerLinks: { + const ref wit.pumpkin.plugin.java_packets.imports.ConfigCConfigServerLinks _payload45 = packet.getConfigCConfigServerLinks(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(14); + auto _listSrc47 = _payload45.links; + auto _list47 = _listSrc47.length ? wit.common.malloc(_listSrc47.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc47.length || _list47); + if (_listSrc47.length) deallocate ~= _list47; + foreach (_elem46_idx, ref _elem46; _listSrc47) { + auto _base46 = _list47 + _elem46_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base46 + size_t.sizeof) = cast(size_t)(_elem46.length); + *cast(void**)(_base46 + 0) = cast(void*)(cast(void*)(_elem46.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload45.links.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(_list47); + break; + } + case _Tag752.configCConfigShowDialog: { + const ref wit.pumpkin.plugin.java_packets.imports.ConfigCConfigShowDialog _payload49 = packet.getConfigCConfigShowDialog(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(15); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload49.dialog.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload49.dialog.ptr)); + break; + } + case _Tag752.configCStoreCookie: { + const ref wit.pumpkin.plugin.java_packets.imports.ConfigCStoreCookie _payload51 = packet.getConfigCStoreCookie(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(16); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload51.key.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload51.key.ptr)); + *cast(size_t*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(size_t)(_payload51.payload.length); + *cast(void**)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload51.payload.ptr)); + break; + } + case _Tag752.configCTransfer: { + const ref wit.pumpkin.plugin.java_packets.imports.ConfigCTransfer _payload53 = packet.getConfigCTransfer(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(17); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload53.host.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload53.host.ptr)); + *cast(uint*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload53.port)); + break; + } + case _Tag752.configCUpdateTags: { + const ref wit.pumpkin.plugin.java_packets.imports.ConfigCUpdateTags _payload55 = packet.getConfigCUpdateTags(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(18); + auto _listSrc57 = _payload55.tags; + auto _list57 = _listSrc57.length ? wit.common.malloc(_listSrc57.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc57.length || _list57); + if (_listSrc57.length) deallocate ~= _list57; + foreach (_elem56_idx, ref _elem56; _listSrc57) { + auto _base56 = _list57 + _elem56_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base56 + size_t.sizeof) = cast(size_t)(_elem56.length); + *cast(void**)(_base56 + 0) = cast(void*)(cast(void*)(_elem56.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload55.tags.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(_list57); + break; + } + case _Tag752.loginCLoginCookieRequest: { + const ref wit.pumpkin.plugin.java_packets.imports.LoginCLoginCookieRequest _payload59 = packet.getLoginCLoginCookieRequest(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(19); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload59.key.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload59.key.ptr)); + break; + } + case _Tag752.loginCLoginDisconnect: { + const ref wit.pumpkin.plugin.java_packets.imports.LoginCLoginDisconnect _payload61 = packet.getLoginCLoginDisconnect(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(20); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload61.jsonReason.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload61.jsonReason.ptr)); + break; + } + case _Tag752.loginCLoginPluginRequest: { + const ref wit.pumpkin.plugin.java_packets.imports.LoginCLoginPluginRequest _payload63 = packet.getLoginCLoginPluginRequest(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(21); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload63.messageId)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload63.channel.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload63.channel.ptr)); + *cast(size_t*)(_retArea.ptr + (16+4*size_t.sizeof)) = cast(size_t)(_payload63.data.length); + *cast(void**)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload63.data.ptr)); + break; + } + case _Tag752.loginCSetCompression: { + const ref wit.pumpkin.plugin.java_packets.imports.LoginCSetCompression _payload65 = packet.getLoginCSetCompression(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(22); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload65.threshold)); + break; + } + case _Tag752.cAcknowledgeBlockChange: { + const ref wit.pumpkin.plugin.java_packets.imports.CAcknowledgeBlockChange _payload67 = packet.getCAcknowledgeBlockChange(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(23); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload67.sequenceId)); + break; + } + case _Tag752.cActionBar: { + const ref wit.pumpkin.plugin.java_packets.imports.CActionBar _payload69 = packet.getCActionBar(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(24); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload69.actionBar.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload69.actionBar.ptr)); + break; + } + case _Tag752.cAddResourcePack: { + const ref wit.pumpkin.plugin.java_packets.imports.CAddResourcePack _payload71 = packet.getCAddResourcePack(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(25); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(_payload71.uuid.high); + *cast(ulong*)(_retArea.ptr + 24) = cast(ulong)(_payload71.uuid.low); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload71.url.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload71.url.ptr)); + *cast(size_t*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(size_t)(_payload71.hash.length); + *cast(void**)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload71.hash.ptr)); + *cast(ubyte*)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload71.forced)); + if (_payload71.promptMessage.isSome) { + ref _payload75 = _payload71.promptMessage.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+5*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+7*size_t.sizeof)) = cast(size_t)(_payload75.length); + *cast(void**)(_retArea.ptr + (32+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload75.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (32+5*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag752.cAwardStats: { + const ref wit.pumpkin.plugin.java_packets.imports.CAwardStats _payload77 = packet.getCAwardStats(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(26); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload77.stats.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload77.stats.ptr)); + break; + } + case _Tag752.cSetBlockDestroyStage: { + const ref wit.pumpkin.plugin.java_packets.imports.CSetBlockDestroyStage _payload79 = packet.getCSetBlockDestroyStage(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(27); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload79.entityId)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload79.location[0])); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload79.location[1])); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload79.location[2])); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload79.destroyStage)); + break; + } + case _Tag752.cBlockEntityData: { + const ref wit.pumpkin.plugin.java_packets.imports.CBlockEntityData _payload81 = packet.getCBlockEntityData(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(28); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload81.location[0])); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload81.location[1])); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload81.location[2])); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload81.rType)); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload81.nbtData.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload81.nbtData.ptr)); + break; + } + case _Tag752.cBlockEvent: { + const ref wit.pumpkin.plugin.java_packets.imports.CBlockEvent _payload83 = packet.getCBlockEvent(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(29); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload83.location[0])); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload83.location[1])); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload83.location[2])); + *cast(ubyte*)(_retArea.ptr + 28) = cast(ubyte)(cast(uint)(_payload83.actionId)); + *cast(ubyte*)(_retArea.ptr + 29) = cast(ubyte)(cast(uint)(_payload83.actionParameter)); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload83.blockType)); + break; + } + case _Tag752.cBlockUpdate: { + const ref wit.pumpkin.plugin.java_packets.imports.CBlockUpdate _payload85 = packet.getCBlockUpdate(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(30); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload85.location[0])); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload85.location[1])); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload85.location[2])); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload85.stateId)); + break; + } + case _Tag752.cBossEvent: { + const ref wit.pumpkin.plugin.java_packets.imports.CBossEvent _payload87 = packet.getCBossEvent(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(31); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(_payload87.uuid.high); + *cast(ulong*)(_retArea.ptr + 24) = cast(ulong)(_payload87.uuid.low); + alias _Tag100 = wit.pumpkin.plugin.java_packets.imports.BosseventAction.Tag; + final switch (_payload87.action.tag) { + case _Tag100.add: { + const ref wit.pumpkin.plugin.java_packets.imports.BosseventActionAdd _payload89 = _payload87.action.getAdd(); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(0); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload89.title.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload89.title.ptr)); + *cast(float*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(float)(_payload89.health); + *cast(uint*)(_retArea.ptr + (36+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload89.color)); + *cast(uint*)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload89.division)); + *cast(ubyte*)(_retArea.ptr + (44+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload89.flags)); + break; + } + case _Tag100.remove: { + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(1); + break; + } + case _Tag100.updateHealth: { + const ref float _payload93 = _payload87.action.getUpdateHealth(); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(2); + *cast(float*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(float)(_payload93); + break; + } + case _Tag100.updateTile: { + const ref WitString _payload95 = _payload87.action.getUpdateTile(); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(3); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload95.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload95.ptr)); + break; + } + case _Tag100.updateStyle: { + const ref wit.pumpkin.plugin.java_packets.imports.BosseventActionUpdateStyle _payload97 = _payload87.action.getUpdateStyle(); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(4); + *cast(uint*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload97.color)); + *cast(uint*)(_retArea.ptr + (36+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload97.dividers)); + break; + } + case _Tag100.updateFlags: { + const ref ubyte _payload99 = _payload87.action.getUpdateFlags(); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(5); + *cast(ubyte*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload99)); + break; + } + } + break; + } + case _Tag752.cBundleDelimiter: { + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(32); + break; + } + case _Tag752.cCenterChunk: { + const ref wit.pumpkin.plugin.java_packets.imports.CCenterChunk _payload104 = packet.getCCenterChunk(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(33); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload104.chunkX)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload104.chunkZ)); + break; + } + case _Tag752.cChangeDifficulty: { + const ref wit.pumpkin.plugin.java_packets.imports.CChangeDifficulty _payload106 = packet.getCChangeDifficulty(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(34); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload106.difficulty)); + *cast(ubyte*)(_retArea.ptr + 17) = cast(ubyte)(cast(uint)(_payload106.locked)); + break; + } + case _Tag752.cChunkBatchEnd: { + const ref wit.pumpkin.plugin.java_packets.imports.CChunkBatchEnd _payload108 = packet.getCChunkBatchEnd(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(35); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload108.batchSize)); + break; + } + case _Tag752.cChunkBatchStart: { + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(36); + break; + } + case _Tag752.cChunksBiomes: { + const ref wit.pumpkin.plugin.java_packets.imports.CChunksBiomes _payload112 = packet.getCChunksBiomes(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(37); + auto _listSrc114 = _payload112.chunks; + auto _list114 = _listSrc114.length ? wit.common.malloc(_listSrc114.length * ((8+2*size_t.sizeof))) : null; + assert(!_listSrc114.length || _list114); + if (_listSrc114.length) deallocate ~= _list114; + foreach (_elem113_idx, ref _elem113; _listSrc114) { + auto _base113 = _list114 + _elem113_idx * ((8+2*size_t.sizeof)); + *cast(uint*)(_base113 + 0) = cast(uint)(cast(uint)(_elem113.chunkX)); + *cast(uint*)(_base113 + 4) = cast(uint)(cast(uint)(_elem113.chunkZ)); + *cast(size_t*)(_base113 + (8+1*size_t.sizeof)) = cast(size_t)(_elem113.data.length); + *cast(void**)(_base113 + 8) = cast(void*)(cast(void*)(_elem113.data.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload112.chunks.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(_list114); + break; + } + case _Tag752.cPlayClearDialog: { + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(38); + break; + } + case _Tag752.cClearTitle: { + const ref wit.pumpkin.plugin.java_packets.imports.CClearTitle _payload118 = packet.getCClearTitle(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(39); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload118.reset)); + break; + } + case _Tag752.cCloseContainer: { + const ref wit.pumpkin.plugin.java_packets.imports.CCloseContainer _payload120 = packet.getCCloseContainer(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(40); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload120.syncId)); + break; + } + case _Tag752.cCombatDeath: { + const ref wit.pumpkin.plugin.java_packets.imports.CCombatDeath _payload122 = packet.getCCombatDeath(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(41); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload122.playerId)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload122.message.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload122.message.ptr)); + break; + } + case _Tag752.cCombatEnter: { + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(42); + break; + } + case _Tag752.cCombatEnd: { + const ref wit.pumpkin.plugin.java_packets.imports.CCombatEnd _payload126 = packet.getCCombatEnd(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(43); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload126.durationTicks)); + break; + } + case _Tag752.cCommandSuggestions: { + const ref wit.pumpkin.plugin.java_packets.imports.CCommandSuggestions _payload128 = packet.getCCommandSuggestions(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(44); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload128.id)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload128.start)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload128.length)); + auto _listSrc134 = _payload128.matches; + auto _list134 = _listSrc134.length ? wit.common.malloc(_listSrc134.length * ((5*size_t.sizeof))) : null; + assert(!_listSrc134.length || _list134); + if (_listSrc134.length) deallocate ~= _list134; + foreach (_elem129_idx, ref _elem129; _listSrc134) { + auto _base129 = _list134 + _elem129_idx * ((5*size_t.sizeof)); + *cast(size_t*)(_base129 + size_t.sizeof) = cast(size_t)(_elem129.suggestion.length); + *cast(void**)(_base129 + 0) = cast(void*)(cast(void*)(_elem129.suggestion.ptr)); + if (_elem129.tooltip.isSome) { + ref _payload133 = _elem129.tooltip.unwrap(); + *cast(ubyte*)(_base129 + (2*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_base129 + (4*size_t.sizeof)) = cast(size_t)(_payload133.length); + *cast(void**)(_base129 + (3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload133.ptr)); + } else { + *cast(ubyte*)(_base129 + (2*size_t.sizeof)) = cast(ubyte)(0); + } + + } + *cast(size_t*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(size_t)(_payload128.matches.length); + *cast(void**)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(void*)(_list134); + break; + } + case _Tag752.cCommands: { + const ref wit.pumpkin.plugin.java_packets.imports.CCommands _payload136 = packet.getCCommands(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(45); + auto _listSrc304 = _payload136.nodes; + auto _list304 = _listSrc304.length ? wit.common.malloc(_listSrc304.length * ((72+4*size_t.sizeof))) : null; + assert(!_listSrc304.length || _list304); + if (_listSrc304.length) deallocate ~= _list304; + foreach (_elem137_idx, ref _elem137; _listSrc304) { + auto _base137 = _list304 + _elem137_idx * ((72+4*size_t.sizeof)); + *cast(size_t*)(_base137 + size_t.sizeof) = cast(size_t)(_elem137.children.length); + *cast(void**)(_base137 + 0) = cast(void*)(cast(void*)(_elem137.children.ptr)); + alias _Tag303 = wit.pumpkin.plugin.java_packets.imports.ProtoNodeType.Tag; + final switch (_elem137.nodeType.tag) { + case _Tag303.root: { + *cast(ubyte*)(_base137 + (2*size_t.sizeof)) = cast(ubyte)(0); + break; + } + case _Tag303.literal: { + const ref wit.pumpkin.plugin.java_packets.imports.ProtoNodeTypeLiteral _payload141 = _elem137.nodeType.getLiteral(); + *cast(ubyte*)(_base137 + (2*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_base137 + (8+3*size_t.sizeof)) = cast(size_t)(_payload141.name.length); + *cast(void**)(_base137 + (8+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload141.name.ptr)); + *cast(ubyte*)(_base137 + (8+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload141.isExecutable)); + if (_payload141.redirectTarget.isSome) { + ref _payload145 = _payload141.redirectTarget.unwrap(); + *cast(ubyte*)(_base137 + (12+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base137 + (16+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload145)); + } else { + *cast(ubyte*)(_base137 + (12+4*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base137 + (20+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload141.restricted)); + break; + } + case _Tag303.argument: { + const ref wit.pumpkin.plugin.java_packets.imports.ProtoNodeTypeArgument _payload147 = _elem137.nodeType.getArgument(); + *cast(ubyte*)(_base137 + (2*size_t.sizeof)) = cast(ubyte)(2); + *cast(size_t*)(_base137 + (8+3*size_t.sizeof)) = cast(size_t)(_payload147.name.length); + *cast(void**)(_base137 + (8+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload147.name.ptr)); + *cast(ubyte*)(_base137 + (8+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload147.isExecutable)); + if (_payload147.redirectTarget.isSome) { + ref _payload151 = _payload147.redirectTarget.unwrap(); + *cast(ubyte*)(_base137 + (12+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base137 + (16+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload151)); + } else { + *cast(ubyte*)(_base137 + (12+4*size_t.sizeof)) = cast(ubyte)(0); + } + alias _Tag298 = wit.pumpkin.plugin.java_packets.imports.ArgumentType.Tag; + final switch (_payload147.parser.tag) { + case _Tag298.bool_: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(0); + break; + } + case _Tag298.float_: { + const ref wit.pumpkin.plugin.java_packets.imports.ArgumentTypeFloat _payload155 = _payload147.parser.getFloat(); + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(1); + if (_payload155.min.isSome) { + ref _payload159 = _payload155.min.unwrap(); + *cast(ubyte*)(_base137 + (32+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(float*)(_base137 + (36+4*size_t.sizeof)) = cast(float)(_payload159); + } else { + *cast(ubyte*)(_base137 + (32+4*size_t.sizeof)) = cast(ubyte)(0); + } + if (_payload155.max.isSome) { + ref _payload163 = _payload155.max.unwrap(); + *cast(ubyte*)(_base137 + (40+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(float*)(_base137 + (44+4*size_t.sizeof)) = cast(float)(_payload163); + } else { + *cast(ubyte*)(_base137 + (40+4*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag298.double_: { + const ref wit.pumpkin.plugin.java_packets.imports.ArgumentTypeDouble _payload165 = _payload147.parser.getDouble(); + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(2); + if (_payload165.min.isSome) { + ref _payload169 = _payload165.min.unwrap(); + *cast(ubyte*)(_base137 + (32+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(double*)(_base137 + (40+4*size_t.sizeof)) = cast(double)(_payload169); + } else { + *cast(ubyte*)(_base137 + (32+4*size_t.sizeof)) = cast(ubyte)(0); + } + if (_payload165.max.isSome) { + ref _payload173 = _payload165.max.unwrap(); + *cast(ubyte*)(_base137 + (48+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(double*)(_base137 + (56+4*size_t.sizeof)) = cast(double)(_payload173); + } else { + *cast(ubyte*)(_base137 + (48+4*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag298.integer: { + const ref wit.pumpkin.plugin.java_packets.imports.ArgumentTypeInteger _payload175 = _payload147.parser.getInteger(); + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(3); + if (_payload175.min.isSome) { + ref _payload179 = _payload175.min.unwrap(); + *cast(ubyte*)(_base137 + (32+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base137 + (36+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload179)); + } else { + *cast(ubyte*)(_base137 + (32+4*size_t.sizeof)) = cast(ubyte)(0); + } + if (_payload175.max.isSome) { + ref _payload183 = _payload175.max.unwrap(); + *cast(ubyte*)(_base137 + (40+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base137 + (44+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload183)); + } else { + *cast(ubyte*)(_base137 + (40+4*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag298.long_: { + const ref wit.pumpkin.plugin.java_packets.imports.ArgumentTypeLong _payload185 = _payload147.parser.getLong(); + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(4); + if (_payload185.min.isSome) { + ref _payload189 = _payload185.min.unwrap(); + *cast(ubyte*)(_base137 + (32+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(ulong*)(_base137 + (40+4*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload189)); + } else { + *cast(ubyte*)(_base137 + (32+4*size_t.sizeof)) = cast(ubyte)(0); + } + if (_payload185.max.isSome) { + ref _payload193 = _payload185.max.unwrap(); + *cast(ubyte*)(_base137 + (48+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(ulong*)(_base137 + (56+4*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload193)); + } else { + *cast(ubyte*)(_base137 + (48+4*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag298.string: { + const ref wit.pumpkin.plugin.java_packets.imports.StringProtoArgBehavior _payload195 = _payload147.parser.getString(); + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(5); + *cast(ubyte*)(_base137 + (32+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload195)); + break; + } + case _Tag298.entity: { + const ref wit.pumpkin.plugin.java_packets.imports.ArgumentTypeEntity _payload197 = _payload147.parser.getEntity(); + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(6); + *cast(ubyte*)(_base137 + (32+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload197.flags)); + break; + } + case _Tag298.gameProfile: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(7); + break; + } + case _Tag298.blockPos: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(8); + break; + } + case _Tag298.columnPos: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(9); + break; + } + case _Tag298.vec3: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(10); + break; + } + case _Tag298.vec2: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(11); + break; + } + case _Tag298.blockState: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(12); + break; + } + case _Tag298.blockPredicate: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(13); + break; + } + case _Tag298.itemStack: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(14); + break; + } + case _Tag298.itemPredicate: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(15); + break; + } + case _Tag298.color: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(16); + break; + } + case _Tag298.hexColor: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(17); + break; + } + case _Tag298.component: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(18); + break; + } + case _Tag298.style: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(19); + break; + } + case _Tag298.message: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(20); + break; + } + case _Tag298.nbtCompound: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(21); + break; + } + case _Tag298.nbtTag: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(22); + break; + } + case _Tag298.nbtPath: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(23); + break; + } + case _Tag298.objective: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(24); + break; + } + case _Tag298.objectiveCriteria: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(25); + break; + } + case _Tag298.operation: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(26); + break; + } + case _Tag298.particle: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(27); + break; + } + case _Tag298.angle: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(28); + break; + } + case _Tag298.rotation: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(29); + break; + } + case _Tag298.scoreboardSlot: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(30); + break; + } + case _Tag298.scoreHolder: { + const ref wit.pumpkin.plugin.java_packets.imports.ArgumentTypeScoreHolder _payload247 = _payload147.parser.getScoreHolder(); + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(31); + *cast(ubyte*)(_base137 + (32+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload247.flags)); + break; + } + case _Tag298.swizzle: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(32); + break; + } + case _Tag298.team: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(33); + break; + } + case _Tag298.itemSlot: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(34); + break; + } + case _Tag298.itemSlots: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(35); + break; + } + case _Tag298.resourceLocation: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(36); + break; + } + case _Tag298.function_: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(37); + break; + } + case _Tag298.entityAnchor: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(38); + break; + } + case _Tag298.intRange: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(39); + break; + } + case _Tag298.floatRange: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(40); + break; + } + case _Tag298.dimension: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(41); + break; + } + case _Tag298.gamemode: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(42); + break; + } + case _Tag298.time: { + const ref wit.pumpkin.plugin.java_packets.imports.ArgumentTypeTime _payload271 = _payload147.parser.getTime(); + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(43); + *cast(uint*)(_base137 + (32+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload271.min)); + break; + } + case _Tag298.resourceOrTag: { + const ref wit.pumpkin.plugin.java_packets.imports.ArgumentTypeResourceOrTag _payload273 = _payload147.parser.getResourceOrTag(); + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(44); + *cast(size_t*)(_base137 + (32+5*size_t.sizeof)) = cast(size_t)(_payload273.identifier.length); + *cast(void**)(_base137 + (32+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload273.identifier.ptr)); + break; + } + case _Tag298.resourceOrTagKey: { + const ref wit.pumpkin.plugin.java_packets.imports.ArgumentTypeResourceOrTagKey _payload275 = _payload147.parser.getResourceOrTagKey(); + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(45); + *cast(size_t*)(_base137 + (32+5*size_t.sizeof)) = cast(size_t)(_payload275.identifier.length); + *cast(void**)(_base137 + (32+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload275.identifier.ptr)); + break; + } + case _Tag298.resource: { + const ref wit.pumpkin.plugin.java_packets.imports.ArgumentTypeResource _payload277 = _payload147.parser.getResource(); + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(46); + *cast(size_t*)(_base137 + (32+5*size_t.sizeof)) = cast(size_t)(_payload277.identifier.length); + *cast(void**)(_base137 + (32+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload277.identifier.ptr)); + break; + } + case _Tag298.resourceKey: { + const ref wit.pumpkin.plugin.java_packets.imports.ArgumentTypeResourceKey _payload279 = _payload147.parser.getResourceKey(); + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(47); + *cast(size_t*)(_base137 + (32+5*size_t.sizeof)) = cast(size_t)(_payload279.identifier.length); + *cast(void**)(_base137 + (32+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload279.identifier.ptr)); + break; + } + case _Tag298.resourceSelector: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(48); + break; + } + case _Tag298.templateMirror: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(49); + break; + } + case _Tag298.templateRotation: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(50); + break; + } + case _Tag298.heightmap: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(51); + break; + } + case _Tag298.lootTable: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(52); + break; + } + case _Tag298.lootPredicate: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(53); + break; + } + case _Tag298.lootModifier: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(54); + break; + } + case _Tag298.dialog: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(55); + break; + } + case _Tag298.uuid: { + *cast(ubyte*)(_base137 + (24+4*size_t.sizeof)) = cast(ubyte)(56); + break; + } + } + if (_payload147.overrideSuggestionType.isSome) { + ref _payload302 = _payload147.overrideSuggestionType.unwrap(); + *cast(ubyte*)(_base137 + (64+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(ubyte*)(_base137 + (65+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload302)); + } else { + *cast(ubyte*)(_base137 + (64+4*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base137 + (66+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload147.restricted)); + break; + } + } + + } + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload136.nodes.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(_list304); + *cast(uint*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload136.rootNodeIndex)); + break; + } + case _Tag752.cPlayCookieRequest: { + const ref wit.pumpkin.plugin.java_packets.imports.CPlayCookieRequest _payload306 = packet.getCPlayCookieRequest(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(46); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload306.key.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload306.key.ptr)); + break; + } + case _Tag752.cCustomChatCompletions: { + const ref wit.pumpkin.plugin.java_packets.imports.CCustomChatCompletions _payload308 = packet.getCCustomChatCompletions(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(47); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload308.action)); + auto _listSrc310 = _payload308.entries; + auto _list310 = _listSrc310.length ? wit.common.malloc(_listSrc310.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc310.length || _list310); + if (_listSrc310.length) deallocate ~= _list310; + foreach (_elem309_idx, ref _elem309; _listSrc310) { + auto _base309 = _list310 + _elem309_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base309 + size_t.sizeof) = cast(size_t)(_elem309.length); + *cast(void**)(_base309 + 0) = cast(void*)(cast(void*)(_elem309.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload308.entries.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(_list310); + break; + } + case _Tag752.cCustomPayload: { + const ref wit.pumpkin.plugin.java_packets.imports.CCustomPayload _payload312 = packet.getCCustomPayload(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(48); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload312.channel.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload312.channel.ptr)); + *cast(size_t*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(size_t)(_payload312.data.length); + *cast(void**)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload312.data.ptr)); + break; + } + case _Tag752.cPlayCustomReportDetails: { + const ref wit.pumpkin.plugin.java_packets.imports.CPlayCustomReportDetails _payload314 = packet.getCPlayCustomReportDetails(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(49); + auto _listSrc316 = _payload314.details; + auto _list316 = _listSrc316.length ? wit.common.malloc(_listSrc316.length * ((4*size_t.sizeof))) : null; + assert(!_listSrc316.length || _list316); + if (_listSrc316.length) deallocate ~= _list316; + foreach (_elem315_idx, ref _elem315; _listSrc316) { + auto _base315 = _list316 + _elem315_idx * ((4*size_t.sizeof)); + *cast(size_t*)(_base315 + size_t.sizeof) = cast(size_t)(_elem315[0].length); + *cast(void**)(_base315 + 0) = cast(void*)(cast(void*)(_elem315[0].ptr)); + *cast(size_t*)(_base315 + (3*size_t.sizeof)) = cast(size_t)(_elem315[1].length); + *cast(void**)(_base315 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem315[1].ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload314.details.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(_list316); + break; + } + case _Tag752.cDamageEvent: { + const ref wit.pumpkin.plugin.java_packets.imports.CDamageEvent _payload318 = packet.getCDamageEvent(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(50); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload318.entityId)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload318.sourceTypeId)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload318.sourceCauseId)); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload318.sourceDirectId)); + if (_payload318.sourcePosition.isSome) { + ref _payload322 = _payload318.sourcePosition.unwrap(); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(1); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload322[0]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload322[1]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload322[2]); + } else { + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(0); + } + break; + } + case _Tag752.cDebugBlockValue: { + const ref wit.pumpkin.plugin.java_packets.imports.CDebugBlockValue _payload324 = packet.getCDebugBlockValue(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(51); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload324.pos[0])); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload324.pos[1])); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload324.pos[2])); + *cast(size_t*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(size_t)(_payload324.name.length); + *cast(void**)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload324.name.ptr)); + *cast(size_t*)(_retArea.ptr + (24+4*size_t.sizeof)) = cast(size_t)(_payload324.value.length); + *cast(void**)(_retArea.ptr + (24+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload324.value.ptr)); + break; + } + case _Tag752.cDebugChunkValue: { + const ref wit.pumpkin.plugin.java_packets.imports.CDebugChunkValue _payload326 = packet.getCDebugChunkValue(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(52); + *cast(double*)(_retArea.ptr + 16) = cast(double)(_payload326.chunkPos[0]); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload326.chunkPos[1]); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload326.name.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload326.name.ptr)); + *cast(size_t*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(size_t)(_payload326.value.length); + *cast(void**)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload326.value.ptr)); + break; + } + case _Tag752.cDebugEntityValue: { + const ref wit.pumpkin.plugin.java_packets.imports.CDebugEntityValue _payload328 = packet.getCDebugEntityValue(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(53); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload328.entityId)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload328.name.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload328.name.ptr)); + *cast(size_t*)(_retArea.ptr + (16+4*size_t.sizeof)) = cast(size_t)(_payload328.value.length); + *cast(void**)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload328.value.ptr)); + break; + } + case _Tag752.cDebugEvent: { + const ref wit.pumpkin.plugin.java_packets.imports.CDebugEvent _payload330 = packet.getCDebugEvent(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(54); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload330.name.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload330.name.ptr)); + *cast(size_t*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(size_t)(_payload330.data.length); + *cast(void**)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload330.data.ptr)); + break; + } + case _Tag752.cDebugSample: { + const ref wit.pumpkin.plugin.java_packets.imports.CDebugSample _payload332 = packet.getCDebugSample(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(55); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload332.sample.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload332.sample.ptr)); + *cast(uint*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload332.sampleType)); + break; + } + case _Tag752.cDeleteChat: { + const ref wit.pumpkin.plugin.java_packets.imports.CDeleteChat _payload334 = packet.getCDeleteChat(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(56); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload334.signatureId)); + if (_payload334.signature.isSome) { + ref _payload338 = _payload334.signature.unwrap(); + *cast(ubyte*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(size_t)(_payload338.length); + *cast(void**)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload338.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag752.cPlayDisconnect: { + const ref wit.pumpkin.plugin.java_packets.imports.CPlayDisconnect _payload340 = packet.getCPlayDisconnect(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(57); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload340.reason.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload340.reason.ptr)); + break; + } + case _Tag752.cDisguisedChatMessage: { + const ref wit.pumpkin.plugin.java_packets.imports.CDisguisedChatMessage _payload342 = packet.getCDisguisedChatMessage(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(58); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload342.message.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload342.message.ptr)); + *cast(uint*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload342.chatType)); + *cast(size_t*)(_retArea.ptr + (16+4*size_t.sizeof)) = cast(size_t)(_payload342.senderName.length); + *cast(void**)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload342.senderName.ptr)); + if (_payload342.targetName.isSome) { + ref _payload346 = _payload342.targetName.unwrap(); + *cast(ubyte*)(_retArea.ptr + (16+5*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (16+7*size_t.sizeof)) = cast(size_t)(_payload346.length); + *cast(void**)(_retArea.ptr + (16+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload346.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (16+5*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag752.cDisplayObjective: { + const ref wit.pumpkin.plugin.java_packets.imports.CDisplayObjective _payload348 = packet.getCDisplayObjective(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(59); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload348.position)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload348.scoreName.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload348.scoreName.ptr)); + break; + } + case _Tag752.cEntityAnimation: { + const ref wit.pumpkin.plugin.java_packets.imports.CEntityAnimation _payload350 = packet.getCEntityAnimation(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(60); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload350.entityId)); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload350.animation)); + break; + } + case _Tag752.cSetEntityMetadata: { + const ref wit.pumpkin.plugin.java_packets.imports.CSetEntityMetadata _payload352 = packet.getCSetEntityMetadata(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(61); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload352.entityId)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload352.metadata.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload352.metadata.ptr)); + break; + } + case _Tag752.cEntitySoundEffect: { + const ref wit.pumpkin.plugin.java_packets.imports.CEntitySoundEffect _payload354 = packet.getCEntitySoundEffect(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(62); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload354.soundEvent.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload354.soundEvent.ptr)); + *cast(uint*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload354.soundCategory)); + *cast(uint*)(_retArea.ptr + (20+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload354.entityId)); + *cast(float*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(float)(_payload354.volume); + *cast(float*)(_retArea.ptr + (28+2*size_t.sizeof)) = cast(float)(_payload354.pitch); + *cast(ulong*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload354.seed)); + break; + } + case _Tag752.cEntityStatus: { + const ref wit.pumpkin.plugin.java_packets.imports.CEntityStatus _payload356 = packet.getCEntityStatus(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(63); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload356.entityId)); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload356.entityStatus)); + break; + } + case _Tag752.cEntityVelocity: { + const ref wit.pumpkin.plugin.java_packets.imports.CEntityVelocity _payload358 = packet.getCEntityVelocity(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(64); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload358.entityId)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload358.velocity.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload358.velocity.ptr)); + break; + } + case _Tag752.cExplosion: { + const ref wit.pumpkin.plugin.java_packets.imports.CExplosion _payload360 = packet.getCExplosion(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(65); + *cast(double*)(_retArea.ptr + 16) = cast(double)(_payload360.center[0]); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload360.center[1]); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload360.center[2]); + *cast(float*)(_retArea.ptr + 40) = cast(float)(_payload360.radius); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload360.blockCount)); + if (_payload360.knockback.isSome) { + ref _payload364 = _payload360.knockback.unwrap(); + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(1); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload364[0]); + *cast(double*)(_retArea.ptr + 64) = cast(double)(_payload364[1]); + *cast(double*)(_retArea.ptr + 72) = cast(double)(_payload364[2]); + } else { + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(0); + } + *cast(uint*)(_retArea.ptr + 80) = cast(uint)(cast(uint)(_payload360.particle)); + *cast(size_t*)(_retArea.ptr + (80+2*size_t.sizeof)) = cast(size_t)(_payload360.sound.length); + *cast(void**)(_retArea.ptr + (80+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload360.sound.ptr)); + *cast(uint*)(_retArea.ptr + (80+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload360.blockParticlesPoolSize)); + break; + } + case _Tag752.cGameEvent: { + const ref wit.pumpkin.plugin.java_packets.imports.CGameEvent _payload366 = packet.getCGameEvent(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(66); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload366.event)); + *cast(float*)(_retArea.ptr + 20) = cast(float)(_payload366.value); + break; + } + case _Tag752.cGameRuleValues: { + const ref wit.pumpkin.plugin.java_packets.imports.CGameRuleValues _payload368 = packet.getCGameRuleValues(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(67); + auto _listSrc370 = _payload368.rules; + auto _list370 = _listSrc370.length ? wit.common.malloc(_listSrc370.length * ((4*size_t.sizeof))) : null; + assert(!_listSrc370.length || _list370); + if (_listSrc370.length) deallocate ~= _list370; + foreach (_elem369_idx, ref _elem369; _listSrc370) { + auto _base369 = _list370 + _elem369_idx * ((4*size_t.sizeof)); + *cast(size_t*)(_base369 + size_t.sizeof) = cast(size_t)(_elem369[0].length); + *cast(void**)(_base369 + 0) = cast(void*)(cast(void*)(_elem369[0].ptr)); + *cast(size_t*)(_base369 + (3*size_t.sizeof)) = cast(size_t)(_elem369[1].length); + *cast(void**)(_base369 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem369[1].ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload368.rules.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(_list370); + break; + } + case _Tag752.cGameTestHighlightPos: { + const ref wit.pumpkin.plugin.java_packets.imports.CGameTestHighlightPos _payload372 = packet.getCGameTestHighlightPos(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(68); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload372.pos[0])); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload372.pos[1])); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload372.pos[2])); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload372.color)); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload372.label.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload372.label.ptr)); + *cast(uint*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload372.durationMs)); + break; + } + case _Tag752.cHeadRot: { + const ref wit.pumpkin.plugin.java_packets.imports.CHeadRot _payload374 = packet.getCHeadRot(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(69); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload374.entityId)); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload374.headYaw)); + break; + } + case _Tag752.cHurtAnimation: { + const ref wit.pumpkin.plugin.java_packets.imports.CHurtAnimation _payload376 = packet.getCHurtAnimation(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(70); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload376.entityId)); + *cast(float*)(_retArea.ptr + 20) = cast(float)(_payload376.yaw); + break; + } + case _Tag752.cInitializeWorldBorder: { + const ref wit.pumpkin.plugin.java_packets.imports.CInitializeWorldBorder _payload378 = packet.getCInitializeWorldBorder(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(71); + *cast(double*)(_retArea.ptr + 16) = cast(double)(_payload378.x); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload378.z); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload378.oldDiameter); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload378.newDiameter); + *cast(ulong*)(_retArea.ptr + 48) = cast(ulong)(cast(ulong)(_payload378.speed)); + *cast(uint*)(_retArea.ptr + 56) = cast(uint)(cast(uint)(_payload378.portalTeleportBoundary)); + *cast(uint*)(_retArea.ptr + 60) = cast(uint)(cast(uint)(_payload378.warningBlocks)); + *cast(uint*)(_retArea.ptr + 64) = cast(uint)(cast(uint)(_payload378.warningTime)); + break; + } + case _Tag752.cItemCooldown: { + const ref wit.pumpkin.plugin.java_packets.imports.CItemCooldown _payload380 = packet.getCItemCooldown(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(72); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload380.group.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload380.group.ptr)); + *cast(uint*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload380.cooldown)); + break; + } + case _Tag752.cKeepAlive: { + const ref wit.pumpkin.plugin.java_packets.imports.CKeepAlive _payload382 = packet.getCKeepAlive(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(73); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(cast(ulong)(_payload382.keepAliveId)); + break; + } + case _Tag752.cLevelEvent: { + const ref wit.pumpkin.plugin.java_packets.imports.CLevelEvent _payload384 = packet.getCLevelEvent(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(74); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload384.event)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload384.location[0])); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload384.location[1])); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload384.location[2])); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload384.data)); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(cast(uint)(_payload384.disableRelativeVolume)); + break; + } + case _Tag752.cLightUpdate: { + const ref wit.pumpkin.plugin.java_packets.imports.CLightUpdate _payload386 = packet.getCLightUpdate(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(75); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload386.chunkX)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload386.chunkZ)); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload386.lightData.trustEdges)); + *cast(size_t*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(size_t)(_payload386.lightData.skyLightMask.length); + *cast(void**)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload386.lightData.skyLightMask.ptr)); + *cast(size_t*)(_retArea.ptr + (24+4*size_t.sizeof)) = cast(size_t)(_payload386.lightData.blockLightMask.length); + *cast(void**)(_retArea.ptr + (24+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload386.lightData.blockLightMask.ptr)); + *cast(size_t*)(_retArea.ptr + (24+6*size_t.sizeof)) = cast(size_t)(_payload386.lightData.emptySkyLightMask.length); + *cast(void**)(_retArea.ptr + (24+5*size_t.sizeof)) = cast(void*)(cast(void*)(_payload386.lightData.emptySkyLightMask.ptr)); + *cast(size_t*)(_retArea.ptr + (24+8*size_t.sizeof)) = cast(size_t)(_payload386.lightData.emptyBlockLightMask.length); + *cast(void**)(_retArea.ptr + (24+7*size_t.sizeof)) = cast(void*)(cast(void*)(_payload386.lightData.emptyBlockLightMask.ptr)); + auto _listSrc388 = _payload386.lightData.skyLightArrays; + auto _list388 = _listSrc388.length ? wit.common.malloc(_listSrc388.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc388.length || _list388); + if (_listSrc388.length) deallocate ~= _list388; + foreach (_elem387_idx, ref _elem387; _listSrc388) { + auto _base387 = _list388 + _elem387_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base387 + size_t.sizeof) = cast(size_t)(_elem387.length); + *cast(void**)(_base387 + 0) = cast(void*)(cast(void*)(_elem387.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (24+10*size_t.sizeof)) = cast(size_t)(_payload386.lightData.skyLightArrays.length); + *cast(void**)(_retArea.ptr + (24+9*size_t.sizeof)) = cast(void*)(_list388); + auto _listSrc390 = _payload386.lightData.blockLightArrays; + auto _list390 = _listSrc390.length ? wit.common.malloc(_listSrc390.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc390.length || _list390); + if (_listSrc390.length) deallocate ~= _list390; + foreach (_elem389_idx, ref _elem389; _listSrc390) { + auto _base389 = _list390 + _elem389_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base389 + size_t.sizeof) = cast(size_t)(_elem389.length); + *cast(void**)(_base389 + 0) = cast(void*)(cast(void*)(_elem389.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (24+12*size_t.sizeof)) = cast(size_t)(_payload386.lightData.blockLightArrays.length); + *cast(void**)(_retArea.ptr + (24+11*size_t.sizeof)) = cast(void*)(_list390); + break; + } + case _Tag752.cLogin: { + const ref wit.pumpkin.plugin.java_packets.imports.CLogin _payload392 = packet.getCLogin(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(76); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload392.entityId)); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload392.isHardcore)); + auto _listSrc394 = _payload392.dimensionNames; + auto _list394 = _listSrc394.length ? wit.common.malloc(_listSrc394.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc394.length || _list394); + if (_listSrc394.length) deallocate ~= _list394; + foreach (_elem393_idx, ref _elem393; _listSrc394) { + auto _base393 = _list394 + _elem393_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base393 + size_t.sizeof) = cast(size_t)(_elem393.length); + *cast(void**)(_base393 + 0) = cast(void*)(cast(void*)(_elem393.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(size_t)(_payload392.dimensionNames.length); + *cast(void**)(_retArea.ptr + 24) = cast(void*)(_list394); + *cast(uint*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload392.maxPlayers)); + *cast(uint*)(_retArea.ptr + (28+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload392.viewDistance)); + *cast(uint*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload392.simulatedDistance)); + *cast(ubyte*)(_retArea.ptr + (36+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload392.reducedDebugInfo)); + *cast(ubyte*)(_retArea.ptr + (37+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload392.enabledRespawnScreen)); + *cast(ubyte*)(_retArea.ptr + (38+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload392.limitedCrafting)); + *cast(size_t*)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(size_t)(_payload392.spawnData.dimension.length); + *cast(void**)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload392.spawnData.dimension.ptr)); + *cast(ulong*)(_retArea.ptr + (40+4*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload392.spawnData.hashedSeed)); + *cast(ubyte*)(_retArea.ptr + (48+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload392.spawnData.gameMode)); + *cast(ubyte*)(_retArea.ptr + (49+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload392.spawnData.previousGamemode)); + *cast(ubyte*)(_retArea.ptr + (50+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload392.spawnData.debug_)); + *cast(ubyte*)(_retArea.ptr + (51+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload392.spawnData.isFlat)); + if (_payload392.spawnData.deathDimensionName.isSome) { + ref _payload398 = _payload392.spawnData.deathDimensionName.unwrap(); + *cast(ubyte*)(_retArea.ptr + (48+5*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (48+7*size_t.sizeof)) = cast(size_t)(_payload398[0].length); + *cast(void**)(_retArea.ptr + (48+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload398[0].ptr)); + *cast(uint*)(_retArea.ptr + (48+8*size_t.sizeof)) = cast(uint)(cast(uint)(_payload398[1][0])); + *cast(uint*)(_retArea.ptr + (52+8*size_t.sizeof)) = cast(uint)(cast(uint)(_payload398[1][1])); + *cast(uint*)(_retArea.ptr + (56+8*size_t.sizeof)) = cast(uint)(cast(uint)(_payload398[1][2])); + } else { + *cast(ubyte*)(_retArea.ptr + (48+5*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(uint*)(_retArea.ptr + (56+9*size_t.sizeof)) = cast(uint)(cast(uint)(_payload392.spawnData.portalCooldown)); + *cast(uint*)(_retArea.ptr + (60+9*size_t.sizeof)) = cast(uint)(cast(uint)(_payload392.spawnData.sealevel)); + *cast(ubyte*)(_retArea.ptr + (72+8*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload392.onlineMode)); + *cast(ubyte*)(_retArea.ptr + (73+8*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload392.enforceSecureChat)); + break; + } + case _Tag752.cLowDiskSpaceWarning: { + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(77); + break; + } + case _Tag752.cMapItemData: { + const ref wit.pumpkin.plugin.java_packets.imports.CMapItemData _payload402 = packet.getCMapItemData(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(78); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload402.mapId)); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload402.scale)); + *cast(ubyte*)(_retArea.ptr + 21) = cast(ubyte)(cast(uint)(_payload402.trackingPosition)); + *cast(ubyte*)(_retArea.ptr + 22) = cast(ubyte)(cast(uint)(_payload402.locked)); + if (_payload402.icons.isSome) { + ref _payload406 = _payload402.icons.unwrap(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(1); + auto _listSrc412 = _payload406; + auto _list412 = _listSrc412.length ? wit.common.malloc(_listSrc412.length * ((8+3*size_t.sizeof))) : null; + assert(!_listSrc412.length || _list412); + if (_listSrc412.length) deallocate ~= _list412; + foreach (_elem407_idx, ref _elem407; _listSrc412) { + auto _base407 = _list412 + _elem407_idx * ((8+3*size_t.sizeof)); + *cast(uint*)(_base407 + 0) = cast(uint)(cast(uint)(_elem407.iconType)); + *cast(ubyte*)(_base407 + 4) = cast(ubyte)(cast(uint)(_elem407.x)); + *cast(ubyte*)(_base407 + 5) = cast(ubyte)(cast(uint)(_elem407.z)); + *cast(ubyte*)(_base407 + 6) = cast(ubyte)(cast(uint)(_elem407.direction)); + if (_elem407.displayName.isSome) { + ref _payload411 = _elem407.displayName.unwrap(); + *cast(ubyte*)(_base407 + 8) = cast(ubyte)(1); + *cast(size_t*)(_base407 + (8+2*size_t.sizeof)) = cast(size_t)(_payload411.length); + *cast(void**)(_base407 + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload411.ptr)); + } else { + *cast(ubyte*)(_base407 + 8) = cast(ubyte)(0); + } + + } + *cast(size_t*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(size_t)(_payload406.length); + *cast(void**)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(void*)(_list412); + } else { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(0); + } + if (_payload402.data.isSome) { + ref _payload416 = _payload402.data.unwrap(); + *cast(ubyte*)(_retArea.ptr + (24+3*size_t.sizeof)) = cast(ubyte)(1); + *cast(ubyte*)(_retArea.ptr + (24+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload416.columns)); + *cast(ubyte*)(_retArea.ptr + (25+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload416.rows)); + *cast(ubyte*)(_retArea.ptr + (26+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload416.x)); + *cast(ubyte*)(_retArea.ptr + (27+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload416.z)); + *cast(size_t*)(_retArea.ptr + (24+6*size_t.sizeof)) = cast(size_t)(_payload416.data.length); + *cast(void**)(_retArea.ptr + (24+5*size_t.sizeof)) = cast(void*)(cast(void*)(_payload416.data.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (24+3*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag752.cMerchantOffers: { + const ref wit.pumpkin.plugin.java_packets.imports.CMerchantOffers _payload418 = packet.getCMerchantOffers(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(79); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload418.windowId)); + auto _listSrc424 = _payload418.offers; + auto _list424 = _listSrc424.length ? wit.common.malloc(_listSrc424.length * ((24+8*size_t.sizeof))) : null; + assert(!_listSrc424.length || _list424); + if (_listSrc424.length) deallocate ~= _list424; + foreach (_elem419_idx, ref _elem419; _listSrc424) { + auto _base419 = _list424 + _elem419_idx * ((24+8*size_t.sizeof)); + *cast(size_t*)(_base419 + size_t.sizeof) = cast(size_t)(_elem419.baseCostA.length); + *cast(void**)(_base419 + 0) = cast(void*)(cast(void*)(_elem419.baseCostA.ptr)); + *cast(size_t*)(_base419 + (3*size_t.sizeof)) = cast(size_t)(_elem419.output.length); + *cast(void**)(_base419 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem419.output.ptr)); + if (_elem419.costB.isSome) { + ref _payload423 = _elem419.costB.unwrap(); + *cast(ubyte*)(_base419 + (4*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_base419 + (6*size_t.sizeof)) = cast(size_t)(_payload423.length); + *cast(void**)(_base419 + (5*size_t.sizeof)) = cast(void*)(cast(void*)(_payload423.ptr)); + } else { + *cast(ubyte*)(_base419 + (4*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base419 + (7*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem419.rewardExp)); + *cast(uint*)(_base419 + (4+7*size_t.sizeof)) = cast(uint)(cast(uint)(_elem419.uses)); + *cast(uint*)(_base419 + (8+7*size_t.sizeof)) = cast(uint)(cast(uint)(_elem419.maxUses)); + *cast(uint*)(_base419 + (12+7*size_t.sizeof)) = cast(uint)(cast(uint)(_elem419.xp)); + *cast(uint*)(_base419 + (16+7*size_t.sizeof)) = cast(uint)(cast(uint)(_elem419.specialPrice)); + *cast(float*)(_base419 + (20+7*size_t.sizeof)) = cast(float)(_elem419.priceMultiplier); + *cast(uint*)(_base419 + (24+7*size_t.sizeof)) = cast(uint)(cast(uint)(_elem419.demand)); + + } + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload418.offers.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(_list424); + *cast(uint*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload418.villagerLevel)); + *cast(uint*)(_retArea.ptr + (20+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload418.experience)); + *cast(ubyte*)(_retArea.ptr + (24+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload418.isRegularVillager)); + *cast(ubyte*)(_retArea.ptr + (25+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload418.canRestock)); + break; + } + case _Tag752.cMoveMinecartAlongTrack: { + const ref wit.pumpkin.plugin.java_packets.imports.CMoveMinecartAlongTrack _payload426 = packet.getCMoveMinecartAlongTrack(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(80); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload426.entityId)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload426.steps.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload426.steps.ptr)); + break; + } + case _Tag752.cMoveVehicle: { + const ref wit.pumpkin.plugin.java_packets.imports.CMoveVehicle _payload428 = packet.getCMoveVehicle(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(81); + *cast(double*)(_retArea.ptr + 16) = cast(double)(_payload428.x); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload428.y); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload428.z); + *cast(float*)(_retArea.ptr + 40) = cast(float)(_payload428.yaw); + *cast(float*)(_retArea.ptr + 44) = cast(float)(_payload428.pitch); + break; + } + case _Tag752.cMultiBlockUpdate: { + const ref wit.pumpkin.plugin.java_packets.imports.CMultiBlockUpdate _payload430 = packet.getCMultiBlockUpdate(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(82); + *cast(double*)(_retArea.ptr + 16) = cast(double)(_payload430.chunkSection[0]); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload430.chunkSection[1]); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload430.chunkSection[2]); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(cast(uint)(_payload430.suppressLightUpdates)); + auto _listSrc432 = _payload430.updates; + auto _list432 = _listSrc432.length ? wit.common.malloc(_listSrc432.length * ((8+3*size_t.sizeof))) : null; + assert(!_listSrc432.length || _list432); + if (_listSrc432.length) deallocate ~= _list432; + foreach (_elem431_idx, ref _elem431; _listSrc432) { + auto _base431 = _list432 + _elem431_idx * ((8+3*size_t.sizeof)); + *cast(uint*)(_base431 + 0) = cast(uint)(cast(uint)(_elem431[0][0])); + *cast(uint*)(_base431 + 4) = cast(uint)(cast(uint)(_elem431[0][1])); + *cast(uint*)(_base431 + 8) = cast(uint)(cast(uint)(_elem431[0][2])); + *cast(size_t*)(_base431 + (8+2*size_t.sizeof)) = cast(size_t)(_elem431[1].length); + *cast(void**)(_base431 + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_elem431[1].ptr)); + + } + *cast(size_t*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(size_t)(_payload430.updates.length); + *cast(void**)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(void*)(_list432); + break; + } + case _Tag752.cOpenBook: { + const ref wit.pumpkin.plugin.java_packets.imports.COpenBook _payload434 = packet.getCOpenBook(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(83); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload434.hand)); + break; + } + case _Tag752.cOpenMountScreen: { + const ref wit.pumpkin.plugin.java_packets.imports.COpenMountScreen _payload436 = packet.getCOpenMountScreen(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(84); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload436.windowId)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload436.slotCount)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload436.entityId)); + break; + } + case _Tag752.cOpenScreen: { + const ref wit.pumpkin.plugin.java_packets.imports.COpenScreen _payload438 = packet.getCOpenScreen(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(85); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload438.syncId)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload438.windowType)); + *cast(size_t*)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(size_t)(_payload438.windowTitle.length); + *cast(void**)(_retArea.ptr + 24) = cast(void*)(cast(void*)(_payload438.windowTitle.ptr)); + break; + } + case _Tag752.cOpenSignEditor: { + const ref wit.pumpkin.plugin.java_packets.imports.COpenSignEditor _payload440 = packet.getCOpenSignEditor(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(86); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload440.location[0])); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload440.location[1])); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload440.location[2])); + *cast(ubyte*)(_retArea.ptr + 28) = cast(ubyte)(cast(uint)(_payload440.isFrontText)); + break; + } + case _Tag752.cParticle: { + const ref wit.pumpkin.plugin.java_packets.imports.CParticle _payload442 = packet.getCParticle(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(87); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload442.forceSpawn)); + *cast(ubyte*)(_retArea.ptr + 17) = cast(ubyte)(cast(uint)(_payload442.important)); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload442.position[0]); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload442.position[1]); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload442.position[2]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload442.offset[0]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload442.offset[1]); + *cast(double*)(_retArea.ptr + 64) = cast(double)(_payload442.offset[2]); + *cast(float*)(_retArea.ptr + 72) = cast(float)(_payload442.maxSpeed); + *cast(uint*)(_retArea.ptr + 76) = cast(uint)(cast(uint)(_payload442.particleCount)); + *cast(uint*)(_retArea.ptr + 80) = cast(uint)(cast(uint)(_payload442.particleId)); + *cast(size_t*)(_retArea.ptr + (80+2*size_t.sizeof)) = cast(size_t)(_payload442.data.length); + *cast(void**)(_retArea.ptr + (80+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload442.data.ptr)); + break; + } + case _Tag752.cPlayPing: { + const ref wit.pumpkin.plugin.java_packets.imports.CPlayPing _payload444 = packet.getCPlayPing(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(88); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload444.id)); + break; + } + case _Tag752.cPingResponse: { + const ref wit.pumpkin.plugin.java_packets.imports.CPingResponse _payload446 = packet.getCPingResponse(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(89); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(cast(ulong)(_payload446.payload)); + break; + } + case _Tag752.cPlaceGhostRecipe: { + const ref wit.pumpkin.plugin.java_packets.imports.CPlaceGhostRecipe _payload448 = packet.getCPlaceGhostRecipe(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(90); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload448.windowId)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload448.recipeId.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload448.recipeId.ptr)); + break; + } + case _Tag752.cPlayerAbilities: { + const ref wit.pumpkin.plugin.java_packets.imports.CPlayerAbilities _payload450 = packet.getCPlayerAbilities(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(91); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload450.flags)); + *cast(float*)(_retArea.ptr + 20) = cast(float)(_payload450.flyingSpeed); + *cast(float*)(_retArea.ptr + 24) = cast(float)(_payload450.fieldOfView); + break; + } + case _Tag752.cPlayerChatMessage: { + const ref wit.pumpkin.plugin.java_packets.imports.CPlayerChatMessage _payload452 = packet.getCPlayerChatMessage(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(92); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload452.globalIndex)); + *cast(ulong*)(_retArea.ptr + 24) = cast(ulong)(_payload452.sender.high); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(_payload452.sender.low); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload452.index)); + if (_payload452.messageSignature.isSome) { + ref _payload456 = _payload452.messageSignature.unwrap(); + *cast(ubyte*)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(size_t)(_payload456.length); + *cast(void**)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload456.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(size_t*)(_retArea.ptr + (40+5*size_t.sizeof)) = cast(size_t)(_payload452.message.length); + *cast(void**)(_retArea.ptr + (40+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload452.message.ptr)); + *cast(ulong*)(_retArea.ptr + (40+6*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload452.timestamp)); + *cast(ulong*)(_retArea.ptr + (48+6*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload452.salt)); + auto _listSrc462 = _payload452.previousMessages; + auto _list462 = _listSrc462.length ? wit.common.malloc(_listSrc462.length * ((4*size_t.sizeof))) : null; + assert(!_listSrc462.length || _list462); + if (_listSrc462.length) deallocate ~= _list462; + foreach (_elem457_idx, ref _elem457; _listSrc462) { + auto _base457 = _list462 + _elem457_idx * ((4*size_t.sizeof)); + *cast(uint*)(_base457 + 0) = cast(uint)(cast(uint)(_elem457.id)); + if (_elem457.signature.isSome) { + ref _payload461 = _elem457.signature.unwrap(); + *cast(ubyte*)(_base457 + size_t.sizeof) = cast(ubyte)(1); + *cast(size_t*)(_base457 + (3*size_t.sizeof)) = cast(size_t)(_payload461.length); + *cast(void**)(_base457 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload461.ptr)); + } else { + *cast(ubyte*)(_base457 + size_t.sizeof) = cast(ubyte)(0); + } + + } + *cast(size_t*)(_retArea.ptr + (56+7*size_t.sizeof)) = cast(size_t)(_payload452.previousMessages.length); + *cast(void**)(_retArea.ptr + (56+6*size_t.sizeof)) = cast(void*)(_list462); + if (_payload452.unsignedContent.isSome) { + ref _payload466 = _payload452.unsignedContent.unwrap(); + *cast(ubyte*)(_retArea.ptr + (56+8*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (56+10*size_t.sizeof)) = cast(size_t)(_payload466.length); + *cast(void**)(_retArea.ptr + (56+9*size_t.sizeof)) = cast(void*)(cast(void*)(_payload466.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (56+8*size_t.sizeof)) = cast(ubyte)(0); + } + alias _Tag473 = wit.pumpkin.plugin.java_packets.imports.FilterType.Tag; + final switch (_payload452.filterType.tag) { + case _Tag473.passThrough: { + *cast(ubyte*)(_retArea.ptr + (56+11*size_t.sizeof)) = cast(ubyte)(0); + break; + } + case _Tag473.fullyFiltered: { + *cast(ubyte*)(_retArea.ptr + (56+11*size_t.sizeof)) = cast(ubyte)(1); + break; + } + case _Tag473.partiallyFiltered: { + const ref WitList!(long) _payload472 = _payload452.filterType.getPartiallyFiltered(); + *cast(ubyte*)(_retArea.ptr + (56+11*size_t.sizeof)) = cast(ubyte)(2); + *cast(size_t*)(_retArea.ptr + (56+13*size_t.sizeof)) = cast(size_t)(_payload472.length); + *cast(void**)(_retArea.ptr + (56+12*size_t.sizeof)) = cast(void*)(cast(void*)(_payload472.ptr)); + break; + } + } + *cast(uint*)(_retArea.ptr + (56+14*size_t.sizeof)) = cast(uint)(cast(uint)(_payload452.chatType)); + *cast(size_t*)(_retArea.ptr + (56+16*size_t.sizeof)) = cast(size_t)(_payload452.senderName.length); + *cast(void**)(_retArea.ptr + (56+15*size_t.sizeof)) = cast(void*)(cast(void*)(_payload452.senderName.ptr)); + if (_payload452.targetName.isSome) { + ref _payload477 = _payload452.targetName.unwrap(); + *cast(ubyte*)(_retArea.ptr + (56+17*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (56+19*size_t.sizeof)) = cast(size_t)(_payload477.length); + *cast(void**)(_retArea.ptr + (56+18*size_t.sizeof)) = cast(void*)(cast(void*)(_payload477.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (56+17*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag752.cPlayerInfoUpdate: { + const ref wit.pumpkin.plugin.java_packets.imports.CPlayerInfoUpdate _payload479 = packet.getCPlayerInfoUpdate(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(93); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload479.actions)); + auto _listSrc512 = _payload479.players; + auto _list512 = _listSrc512.length ? wit.common.malloc(_listSrc512.length * ((16+2*size_t.sizeof))) : null; + assert(!_listSrc512.length || _list512); + if (_listSrc512.length) deallocate ~= _list512; + foreach (_elem480_idx, ref _elem480; _listSrc512) { + auto _base480 = _list512 + _elem480_idx * ((16+2*size_t.sizeof)); + *cast(ulong*)(_base480 + 0) = cast(ulong)(_elem480.uuid.high); + *cast(ulong*)(_base480 + 8) = cast(ulong)(_elem480.uuid.low); + auto _listSrc511 = _elem480.actions; + auto _list511 = _listSrc511.length ? wit.common.malloc(_listSrc511.length * ((40+4*size_t.sizeof))) : null; + assert(!_listSrc511.length || _list511); + if (_listSrc511.length) deallocate ~= _list511; + foreach (_elem481_idx, ref _elem481; _listSrc511) { + auto _base481 = _list511 + _elem481_idx * ((40+4*size_t.sizeof)); + alias _Tag510 = wit.pumpkin.plugin.java_packets.imports.PlayerAction.Tag; + final switch (_elem481.tag) { + case _Tag510.addPlayer: { + const ref wit.pumpkin.plugin.java_packets.imports.PlayerActionAddPlayer _payload483 = _elem481.getAddPlayer(); + *cast(ubyte*)(_base481 + 0) = cast(ubyte)(0); + *cast(size_t*)(_base481 + (8+1*size_t.sizeof)) = cast(size_t)(_payload483.name.length); + *cast(void**)(_base481 + 8) = cast(void*)(cast(void*)(_payload483.name.ptr)); + auto _listSrc487 = _payload483.properties; + auto _list487 = _listSrc487.length ? wit.common.malloc(_listSrc487.length * ((16+2*size_t.sizeof))) : null; + assert(!_listSrc487.length || _list487); + if (_listSrc487.length) deallocate ~= _list487; + foreach (_elem484_idx, ref _elem484; _listSrc487) { + auto _base484 = _list487 + _elem484_idx * ((16+2*size_t.sizeof)); + *cast(uint*)(_base484 + 0) = cast(uint)(cast(uint)(_elem484.id)); + *cast(double*)(_base484 + 8) = cast(double)(_elem484.value); + auto _listSrc486 = _elem484.modifiers; + auto _list486 = _listSrc486.length ? wit.common.malloc(_listSrc486.length * ((16+2*size_t.sizeof))) : null; + assert(!_listSrc486.length || _list486); + if (_listSrc486.length) deallocate ~= _list486; + foreach (_elem485_idx, ref _elem485; _listSrc486) { + auto _base485 = _list486 + _elem485_idx * ((16+2*size_t.sizeof)); + *cast(size_t*)(_base485 + size_t.sizeof) = cast(size_t)(_elem485.id.length); + *cast(void**)(_base485 + 0) = cast(void*)(cast(void*)(_elem485.id.ptr)); + *cast(double*)(_base485 + (2*size_t.sizeof)) = cast(double)(_elem485.amount); + *cast(ubyte*)(_base485 + (8+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem485.operation)); + + } + *cast(size_t*)(_base484 + (16+1*size_t.sizeof)) = cast(size_t)(_elem484.modifiers.length); + *cast(void**)(_base484 + 16) = cast(void*)(_list486); + + } + *cast(size_t*)(_base481 + (8+3*size_t.sizeof)) = cast(size_t)(_payload483.properties.length); + *cast(void**)(_base481 + (8+2*size_t.sizeof)) = cast(void*)(_list487); + break; + } + case _Tag510.initializeChat: { + const ref Option!(wit.pumpkin.plugin.java_packets.imports.InitChat) _payload489 = _elem481.getInitializeChat(); + *cast(ubyte*)(_base481 + 0) = cast(ubyte)(1); + if (_payload489.isSome) { + ref _payload493 = _payload489.unwrap(); + *cast(ubyte*)(_base481 + 8) = cast(ubyte)(1); + *cast(ulong*)(_base481 + 16) = cast(ulong)(_payload493.sessionId.high); + *cast(ulong*)(_base481 + 24) = cast(ulong)(_payload493.sessionId.low); + *cast(ulong*)(_base481 + 32) = cast(ulong)(cast(ulong)(_payload493.expiresAt)); + *cast(size_t*)(_base481 + (40+1*size_t.sizeof)) = cast(size_t)(_payload493.publicKey.length); + *cast(void**)(_base481 + 40) = cast(void*)(cast(void*)(_payload493.publicKey.ptr)); + *cast(size_t*)(_base481 + (40+3*size_t.sizeof)) = cast(size_t)(_payload493.signature.length); + *cast(void**)(_base481 + (40+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload493.signature.ptr)); + } else { + *cast(ubyte*)(_base481 + 8) = cast(ubyte)(0); + } + break; + } + case _Tag510.updateGameMode: { + const ref int _payload495 = _elem481.getUpdateGameMode(); + *cast(ubyte*)(_base481 + 0) = cast(ubyte)(2); + *cast(uint*)(_base481 + 8) = cast(uint)(cast(uint)(_payload495)); + break; + } + case _Tag510.updateListed: { + const ref bool _payload497 = _elem481.getUpdateListed(); + *cast(ubyte*)(_base481 + 0) = cast(ubyte)(3); + *cast(ubyte*)(_base481 + 8) = cast(ubyte)(cast(uint)(_payload497)); + break; + } + case _Tag510.updateLatency: { + const ref int _payload499 = _elem481.getUpdateLatency(); + *cast(ubyte*)(_base481 + 0) = cast(ubyte)(4); + *cast(uint*)(_base481 + 8) = cast(uint)(cast(uint)(_payload499)); + break; + } + case _Tag510.updateDisplayName: { + const ref Option!(WitString) _payload501 = _elem481.getUpdateDisplayName(); + *cast(ubyte*)(_base481 + 0) = cast(ubyte)(5); + if (_payload501.isSome) { + ref _payload505 = _payload501.unwrap(); + *cast(ubyte*)(_base481 + 8) = cast(ubyte)(1); + *cast(size_t*)(_base481 + (8+2*size_t.sizeof)) = cast(size_t)(_payload505.length); + *cast(void**)(_base481 + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload505.ptr)); + } else { + *cast(ubyte*)(_base481 + 8) = cast(ubyte)(0); + } + break; + } + case _Tag510.updateListOrder: { + const ref int _payload507 = _elem481.getUpdateListOrder(); + *cast(ubyte*)(_base481 + 0) = cast(ubyte)(6); + *cast(uint*)(_base481 + 8) = cast(uint)(cast(uint)(_payload507)); + break; + } + case _Tag510.updateHat: { + const ref bool _payload509 = _elem481.getUpdateHat(); + *cast(ubyte*)(_base481 + 0) = cast(ubyte)(7); + *cast(ubyte*)(_base481 + 8) = cast(ubyte)(cast(uint)(_payload509)); + break; + } + } + + } + *cast(size_t*)(_base480 + (16+1*size_t.sizeof)) = cast(size_t)(_elem480.actions.length); + *cast(void**)(_base480 + 16) = cast(void*)(_list511); + + } + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload479.players.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(_list512); + break; + } + case _Tag752.cPlayerLookAt: { + const ref wit.pumpkin.plugin.java_packets.imports.CPlayerLookAt _payload514 = packet.getCPlayerLookAt(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(94); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload514.fromAnchor)); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload514.targetX); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload514.targetY); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload514.targetZ); + if (_payload514.entity.isSome) { + ref _payload518 = _payload514.entity.unwrap(); + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 52) = cast(uint)(cast(uint)(_payload518[0])); + *cast(uint*)(_retArea.ptr + 56) = cast(uint)(cast(uint)(_payload518[1])); + } else { + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(0); + } + break; + } + case _Tag752.cPlayerPosition: { + const ref wit.pumpkin.plugin.java_packets.imports.CPlayerPosition _payload520 = packet.getCPlayerPosition(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(95); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload520.teleportId)); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload520.position[0]); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload520.position[1]); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload520.position[2]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload520.delta[0]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload520.delta[1]); + *cast(double*)(_retArea.ptr + 64) = cast(double)(_payload520.delta[2]); + *cast(float*)(_retArea.ptr + 72) = cast(float)(_payload520.yaw); + *cast(float*)(_retArea.ptr + 76) = cast(float)(_payload520.pitch); + auto _listSrc522 = _payload520.relatives; + auto _list522 = _listSrc522.length ? wit.common.malloc(_listSrc522.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc522.length || _list522); + if (_listSrc522.length) deallocate ~= _list522; + foreach (_elem521_idx, ref _elem521; _listSrc522) { + auto _base521 = _list522 + _elem521_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base521 + size_t.sizeof) = cast(size_t)(_elem521.length); + *cast(void**)(_base521 + 0) = cast(void*)(cast(void*)(_elem521.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (80+1*size_t.sizeof)) = cast(size_t)(_payload520.relatives.length); + *cast(void**)(_retArea.ptr + 80) = cast(void*)(_list522); + break; + } + case _Tag752.cRemovePlayerInfo: { + const ref wit.pumpkin.plugin.java_packets.imports.CRemovePlayerInfo _payload524 = packet.getCRemovePlayerInfo(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(96); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload524.players.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload524.players.ptr)); + break; + } + case _Tag752.cPlayerRotation: { + const ref wit.pumpkin.plugin.java_packets.imports.CPlayerRotation _payload526 = packet.getCPlayerRotation(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(97); + *cast(float*)(_retArea.ptr + 16) = cast(float)(_payload526.yaw); + *cast(float*)(_retArea.ptr + 20) = cast(float)(_payload526.pitch); + break; + } + case _Tag752.cPlayerSpawnPosition: { + const ref wit.pumpkin.plugin.java_packets.imports.CPlayerSpawnPosition _payload528 = packet.getCPlayerSpawnPosition(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(98); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload528.dimensionName.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload528.dimensionName.ptr)); + *cast(uint*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload528.location[0])); + *cast(uint*)(_retArea.ptr + (20+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload528.location[1])); + *cast(uint*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload528.location[2])); + *cast(float*)(_retArea.ptr + (28+2*size_t.sizeof)) = cast(float)(_payload528.yaw); + *cast(float*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(float)(_payload528.pitch); + break; + } + case _Tag752.cProjectilePower: { + const ref wit.pumpkin.plugin.java_packets.imports.CProjectilePower _payload530 = packet.getCProjectilePower(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(99); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload530.entityId)); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload530.xPower); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload530.yPower); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload530.zPower); + break; + } + case _Tag752.cRecipeBookAdd: { + const ref wit.pumpkin.plugin.java_packets.imports.CRecipeBookAdd _payload532 = packet.getCRecipeBookAdd(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(100); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload532.replace)); + break; + } + case _Tag752.cRecipeBookRemove: { + const ref wit.pumpkin.plugin.java_packets.imports.CRecipeBookRemove _payload534 = packet.getCRecipeBookRemove(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(101); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload534.recipes.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload534.recipes.ptr)); + break; + } + case _Tag752.cRecipeBookSettings: { + const ref wit.pumpkin.plugin.java_packets.imports.CRecipeBookSettings _payload536 = packet.getCRecipeBookSettings(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(102); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload536.craftingOpen)); + *cast(ubyte*)(_retArea.ptr + 17) = cast(ubyte)(cast(uint)(_payload536.craftingFiltering)); + *cast(ubyte*)(_retArea.ptr + 18) = cast(ubyte)(cast(uint)(_payload536.furnaceOpen)); + *cast(ubyte*)(_retArea.ptr + 19) = cast(ubyte)(cast(uint)(_payload536.furnaceFiltering)); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload536.blastFurnaceOpen)); + *cast(ubyte*)(_retArea.ptr + 21) = cast(ubyte)(cast(uint)(_payload536.blastFurnaceFiltering)); + *cast(ubyte*)(_retArea.ptr + 22) = cast(ubyte)(cast(uint)(_payload536.smokerOpen)); + *cast(ubyte*)(_retArea.ptr + 23) = cast(ubyte)(cast(uint)(_payload536.smokerFiltering)); + break; + } + case _Tag752.cRemoveEntities: { + const ref wit.pumpkin.plugin.java_packets.imports.CRemoveEntities _payload538 = packet.getCRemoveEntities(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(103); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload538.entityIds.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload538.entityIds.ptr)); + break; + } + case _Tag752.cRemoveMobEffect: { + const ref wit.pumpkin.plugin.java_packets.imports.CRemoveMobEffect _payload540 = packet.getCRemoveMobEffect(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(104); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload540.entityId)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload540.effectId)); + break; + } + case _Tag752.cRemoveResourcePack: { + const ref wit.pumpkin.plugin.java_packets.imports.CRemoveResourcePack _payload542 = packet.getCRemoveResourcePack(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(105); + if (_payload542.uuid.isSome) { + ref _payload546 = _payload542.uuid.unwrap(); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(1); + *cast(ulong*)(_retArea.ptr + 24) = cast(ulong)(_payload546.high); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(_payload546.low); + } else { + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(0); + } + break; + } + case _Tag752.cResetScore: { + const ref wit.pumpkin.plugin.java_packets.imports.CResetScore _payload548 = packet.getCResetScore(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(106); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload548.entityName.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload548.entityName.ptr)); + if (_payload548.objectiveName.isSome) { + ref _payload552 = _payload548.objectiveName.unwrap(); + *cast(ubyte*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (16+4*size_t.sizeof)) = cast(size_t)(_payload552.length); + *cast(void**)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload552.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag752.cRespawn: { + const ref wit.pumpkin.plugin.java_packets.imports.CRespawn _payload554 = packet.getCRespawn(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(107); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload554.playerSpawnInfo.dimension.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload554.playerSpawnInfo.dimension.ptr)); + *cast(ulong*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload554.playerSpawnInfo.hashedSeed)); + *cast(ubyte*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload554.playerSpawnInfo.gameMode)); + *cast(ubyte*)(_retArea.ptr + (25+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload554.playerSpawnInfo.previousGamemode)); + *cast(ubyte*)(_retArea.ptr + (26+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload554.playerSpawnInfo.debug_)); + *cast(ubyte*)(_retArea.ptr + (27+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload554.playerSpawnInfo.isFlat)); + if (_payload554.playerSpawnInfo.deathDimensionName.isSome) { + ref _payload558 = _payload554.playerSpawnInfo.deathDimensionName.unwrap(); + *cast(ubyte*)(_retArea.ptr + (24+3*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (24+5*size_t.sizeof)) = cast(size_t)(_payload558[0].length); + *cast(void**)(_retArea.ptr + (24+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload558[0].ptr)); + *cast(uint*)(_retArea.ptr + (24+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload558[1][0])); + *cast(uint*)(_retArea.ptr + (28+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload558[1][1])); + *cast(uint*)(_retArea.ptr + (32+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload558[1][2])); + } else { + *cast(ubyte*)(_retArea.ptr + (24+3*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(uint*)(_retArea.ptr + (32+7*size_t.sizeof)) = cast(uint)(cast(uint)(_payload554.playerSpawnInfo.portalCooldown)); + *cast(uint*)(_retArea.ptr + (36+7*size_t.sizeof)) = cast(uint)(cast(uint)(_payload554.playerSpawnInfo.sealevel)); + *cast(ubyte*)(_retArea.ptr + (48+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload554.dataKept)); + break; + } + case _Tag752.cSelectAdvancementsTab: { + const ref wit.pumpkin.plugin.java_packets.imports.CSelectAdvancementsTab _payload560 = packet.getCSelectAdvancementsTab(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(108); + if (_payload560.tabId.isSome) { + ref _payload564 = _payload560.tabId.unwrap(); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload564.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload564.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(0); + } + break; + } + case _Tag752.cServerData: { + const ref wit.pumpkin.plugin.java_packets.imports.CServerData _payload566 = packet.getCServerData(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(109); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload566.motd.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload566.motd.ptr)); + if (_payload566.iconBase64.isSome) { + ref _payload570 = _payload566.iconBase64.unwrap(); + *cast(ubyte*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (16+4*size_t.sizeof)) = cast(size_t)(_payload570.length); + *cast(void**)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload570.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag752.cPlayServerLinks: { + const ref wit.pumpkin.plugin.java_packets.imports.CPlayServerLinks _payload572 = packet.getCPlayServerLinks(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(110); + auto _listSrc574 = _payload572.links; + auto _list574 = _listSrc574.length ? wit.common.malloc(_listSrc574.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc574.length || _list574); + if (_listSrc574.length) deallocate ~= _list574; + foreach (_elem573_idx, ref _elem573; _listSrc574) { + auto _base573 = _list574 + _elem573_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base573 + size_t.sizeof) = cast(size_t)(_elem573.length); + *cast(void**)(_base573 + 0) = cast(void*)(cast(void*)(_elem573.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload572.links.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(_list574); + break; + } + case _Tag752.cSetBorderCenter: { + const ref wit.pumpkin.plugin.java_packets.imports.CSetBorderCenter _payload576 = packet.getCSetBorderCenter(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(111); + *cast(double*)(_retArea.ptr + 16) = cast(double)(_payload576.x); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload576.z); + break; + } + case _Tag752.cSetBorderLerpSize: { + const ref wit.pumpkin.plugin.java_packets.imports.CSetBorderLerpSize _payload578 = packet.getCSetBorderLerpSize(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(112); + *cast(double*)(_retArea.ptr + 16) = cast(double)(_payload578.oldDiameter); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload578.newDiameter); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload578.speed)); + break; + } + case _Tag752.cSetBorderSize: { + const ref wit.pumpkin.plugin.java_packets.imports.CSetBorderSize _payload580 = packet.getCSetBorderSize(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(113); + *cast(double*)(_retArea.ptr + 16) = cast(double)(_payload580.diameter); + break; + } + case _Tag752.cSetBorderWarningDelay: { + const ref wit.pumpkin.plugin.java_packets.imports.CSetBorderWarningDelay _payload582 = packet.getCSetBorderWarningDelay(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(114); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload582.warningTime)); + break; + } + case _Tag752.cSetBorderWarningDistance: { + const ref wit.pumpkin.plugin.java_packets.imports.CSetBorderWarningDistance _payload584 = packet.getCSetBorderWarningDistance(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(115); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload584.warningBlocks)); + break; + } + case _Tag752.cSetCamera: { + const ref wit.pumpkin.plugin.java_packets.imports.CSetCamera _payload586 = packet.getCSetCamera(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(116); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload586.cameraId)); + break; + } + case _Tag752.cSetChunkCacheRadius: { + const ref wit.pumpkin.plugin.java_packets.imports.CSetChunkCacheRadius _payload588 = packet.getCSetChunkCacheRadius(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(117); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload588.radius)); + break; + } + case _Tag752.cSetContainerContent: { + const ref wit.pumpkin.plugin.java_packets.imports.CSetContainerContent _payload590 = packet.getCSetContainerContent(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(118); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload590.windowId)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload590.stateId)); + auto _listSrc592 = _payload590.slotData; + auto _list592 = _listSrc592.length ? wit.common.malloc(_listSrc592.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc592.length || _list592); + if (_listSrc592.length) deallocate ~= _list592; + foreach (_elem591_idx, ref _elem591; _listSrc592) { + auto _base591 = _list592 + _elem591_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base591 + size_t.sizeof) = cast(size_t)(_elem591.length); + *cast(void**)(_base591 + 0) = cast(void*)(cast(void*)(_elem591.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(size_t)(_payload590.slotData.length); + *cast(void**)(_retArea.ptr + 24) = cast(void*)(_list592); + *cast(size_t*)(_retArea.ptr + (24+3*size_t.sizeof)) = cast(size_t)(_payload590.carriedItem.length); + *cast(void**)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload590.carriedItem.ptr)); + break; + } + case _Tag752.cSetContainerProperty: { + const ref wit.pumpkin.plugin.java_packets.imports.CSetContainerProperty _payload594 = packet.getCSetContainerProperty(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(119); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload594.windowId)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload594.property)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload594.value)); + break; + } + case _Tag752.cSetContainerSlot: { + const ref wit.pumpkin.plugin.java_packets.imports.CSetContainerSlot _payload596 = packet.getCSetContainerSlot(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(120); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload596.windowId)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload596.stateId)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload596.slot)); + *cast(size_t*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(size_t)(_payload596.slotData.length); + *cast(void**)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload596.slotData.ptr)); + break; + } + case _Tag752.cSetCursorItem: { + const ref wit.pumpkin.plugin.java_packets.imports.CSetCursorItem _payload598 = packet.getCSetCursorItem(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(121); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload598.stack.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload598.stack.ptr)); + break; + } + case _Tag752.cSetEntityLink: { + const ref wit.pumpkin.plugin.java_packets.imports.CSetEntityLink _payload600 = packet.getCSetEntityLink(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(122); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload600.attachedEntityId)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload600.holdingEntityId)); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload600.leash)); + break; + } + case _Tag752.cSetEquipment: { + const ref wit.pumpkin.plugin.java_packets.imports.CSetEquipment _payload602 = packet.getCSetEquipment(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(123); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload602.entityId)); + auto _listSrc604 = _payload602.equipment; + auto _list604 = _listSrc604.length ? wit.common.malloc(_listSrc604.length * ((3*size_t.sizeof))) : null; + assert(!_listSrc604.length || _list604); + if (_listSrc604.length) deallocate ~= _list604; + foreach (_elem603_idx, ref _elem603; _listSrc604) { + auto _base603 = _list604 + _elem603_idx * ((3*size_t.sizeof)); + *cast(ubyte*)(_base603 + 0) = cast(ubyte)(cast(uint)(_elem603[0])); + *cast(size_t*)(_base603 + (2*size_t.sizeof)) = cast(size_t)(_elem603[1].length); + *cast(void**)(_base603 + size_t.sizeof) = cast(void*)(cast(void*)(_elem603[1].ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload602.equipment.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(_list604); + break; + } + case _Tag752.cSetExperience: { + const ref wit.pumpkin.plugin.java_packets.imports.CSetExperience _payload606 = packet.getCSetExperience(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(124); + *cast(float*)(_retArea.ptr + 16) = cast(float)(_payload606.progress); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload606.level)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload606.totalExperience)); + break; + } + case _Tag752.cSetHealth: { + const ref wit.pumpkin.plugin.java_packets.imports.CSetHealth _payload608 = packet.getCSetHealth(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(125); + *cast(float*)(_retArea.ptr + 16) = cast(float)(_payload608.health); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload608.food)); + *cast(float*)(_retArea.ptr + 24) = cast(float)(_payload608.foodSaturation); + break; + } + case _Tag752.cSetPassengers: { + const ref wit.pumpkin.plugin.java_packets.imports.CSetPassengers _payload610 = packet.getCSetPassengers(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(126); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload610.entityId)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload610.passengers.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload610.passengers.ptr)); + break; + } + case _Tag752.cSetPlayerInventory: { + const ref wit.pumpkin.plugin.java_packets.imports.CSetPlayerInventory _payload612 = packet.getCSetPlayerInventory(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(127); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload612.slot)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload612.item.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload612.item.ptr)); + break; + } + case _Tag752.cSetPlayerTeam: { + const ref wit.pumpkin.plugin.java_packets.imports.CSetPlayerTeam _payload614 = packet.getCSetPlayerTeam(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(128); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload614.teamName.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload614.teamName.ptr)); + *cast(ubyte*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload614.method)); + if (_payload614.parameters.isSome) { + ref _payload618 = _payload614.parameters.unwrap(); + *cast(ubyte*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (16+5*size_t.sizeof)) = cast(size_t)(_payload618.displayName.length); + *cast(void**)(_retArea.ptr + (16+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload618.displayName.ptr)); + *cast(ubyte*)(_retArea.ptr + (16+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload618.options)); + *cast(size_t*)(_retArea.ptr + (16+8*size_t.sizeof)) = cast(size_t)(_payload618.nametagVisibility.length); + *cast(void**)(_retArea.ptr + (16+7*size_t.sizeof)) = cast(void*)(cast(void*)(_payload618.nametagVisibility.ptr)); + *cast(size_t*)(_retArea.ptr + (16+10*size_t.sizeof)) = cast(size_t)(_payload618.collisionRule.length); + *cast(void**)(_retArea.ptr + (16+9*size_t.sizeof)) = cast(void*)(cast(void*)(_payload618.collisionRule.ptr)); + *cast(uint*)(_retArea.ptr + (16+11*size_t.sizeof)) = cast(uint)(cast(uint)(_payload618.color)); + *cast(size_t*)(_retArea.ptr + (16+13*size_t.sizeof)) = cast(size_t)(_payload618.playerPrefix.length); + *cast(void**)(_retArea.ptr + (16+12*size_t.sizeof)) = cast(void*)(cast(void*)(_payload618.playerPrefix.ptr)); + *cast(size_t*)(_retArea.ptr + (16+15*size_t.sizeof)) = cast(size_t)(_payload618.playerSuffix.length); + *cast(void**)(_retArea.ptr + (16+14*size_t.sizeof)) = cast(void*)(cast(void*)(_payload618.playerSuffix.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(ubyte)(0); + } + auto _listSrc620 = _payload614.players; + auto _list620 = _listSrc620.length ? wit.common.malloc(_listSrc620.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc620.length || _list620); + if (_listSrc620.length) deallocate ~= _list620; + foreach (_elem619_idx, ref _elem619; _listSrc620) { + auto _base619 = _list620 + _elem619_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base619 + size_t.sizeof) = cast(size_t)(_elem619.length); + *cast(void**)(_base619 + 0) = cast(void*)(cast(void*)(_elem619.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+17*size_t.sizeof)) = cast(size_t)(_payload614.players.length); + *cast(void**)(_retArea.ptr + (16+16*size_t.sizeof)) = cast(void*)(_list620); + break; + } + case _Tag752.cSetSimulationDistance: { + const ref wit.pumpkin.plugin.java_packets.imports.CSetSimulationDistance _payload622 = packet.getCSetSimulationDistance(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(129); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload622.simulationDistance)); + break; + } + case _Tag752.cUpdateTime: { + const ref wit.pumpkin.plugin.java_packets.imports.CUpdateTime _payload624 = packet.getCUpdateTime(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(130); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(cast(ulong)(_payload624.gameTime)); + *cast(size_t*)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(size_t)(_payload624.clockUpdates.length); + *cast(void**)(_retArea.ptr + 24) = cast(void*)(cast(void*)(_payload624.clockUpdates.ptr)); + break; + } + case _Tag752.cTitleText: { + const ref wit.pumpkin.plugin.java_packets.imports.CTitleText _payload626 = packet.getCTitleText(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(131); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload626.title.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload626.title.ptr)); + break; + } + case _Tag752.cTitleAnimation: { + const ref wit.pumpkin.plugin.java_packets.imports.CTitleAnimation _payload628 = packet.getCTitleAnimation(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(132); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload628.fadeInTicks)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload628.stayTicks)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload628.fadeOutTicks)); + break; + } + case _Tag752.cPlayShowDialog: { + const ref wit.pumpkin.plugin.java_packets.imports.CPlayShowDialog _payload630 = packet.getCPlayShowDialog(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(133); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload630.dialog.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload630.dialog.ptr)); + break; + } + case _Tag752.cSoundEffect: { + const ref wit.pumpkin.plugin.java_packets.imports.CSoundEffect _payload632 = packet.getCSoundEffect(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(134); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload632.soundEvent.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload632.soundEvent.ptr)); + *cast(uint*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload632.soundCategory)); + *cast(double*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(double)(_payload632.position[0]); + *cast(double*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(double)(_payload632.position[1]); + *cast(double*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(double)(_payload632.position[2]); + *cast(float*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(float)(_payload632.volume); + *cast(float*)(_retArea.ptr + (52+2*size_t.sizeof)) = cast(float)(_payload632.pitch); + *cast(double*)(_retArea.ptr + (56+2*size_t.sizeof)) = cast(double)(_payload632.seed); + break; + } + case _Tag752.cSpawnEntity: { + const ref wit.pumpkin.plugin.java_packets.imports.CSpawnEntity _payload634 = packet.getCSpawnEntity(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(135); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload634.entityId)); + *cast(ulong*)(_retArea.ptr + 24) = cast(ulong)(_payload634.entityUuid.high); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(_payload634.entityUuid.low); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload634.rType)); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload634.position[0]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload634.position[1]); + *cast(double*)(_retArea.ptr + 64) = cast(double)(_payload634.position[2]); + *cast(size_t*)(_retArea.ptr + (72+1*size_t.sizeof)) = cast(size_t)(_payload634.velocity.length); + *cast(void**)(_retArea.ptr + 72) = cast(void*)(cast(void*)(_payload634.velocity.ptr)); + *cast(ubyte*)(_retArea.ptr + (72+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload634.pitch)); + *cast(ubyte*)(_retArea.ptr + (73+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload634.yaw)); + *cast(ubyte*)(_retArea.ptr + (74+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload634.headYaw)); + *cast(uint*)(_retArea.ptr + (76+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload634.data)); + break; + } + case _Tag752.cSpawnLivingEntity: { + const ref wit.pumpkin.plugin.java_packets.imports.CSpawnLivingEntity _payload636 = packet.getCSpawnLivingEntity(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(136); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload636.entityId)); + *cast(ulong*)(_retArea.ptr + 24) = cast(ulong)(_payload636.entityUuid.high); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(_payload636.entityUuid.low); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload636.rType)); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload636.position[0]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload636.position[1]); + *cast(double*)(_retArea.ptr + 64) = cast(double)(_payload636.position[2]); + *cast(ubyte*)(_retArea.ptr + 72) = cast(ubyte)(cast(uint)(_payload636.yaw)); + *cast(ubyte*)(_retArea.ptr + 73) = cast(ubyte)(cast(uint)(_payload636.pitch)); + *cast(ubyte*)(_retArea.ptr + 74) = cast(ubyte)(cast(uint)(_payload636.headYaw)); + *cast(size_t*)(_retArea.ptr + (72+2*size_t.sizeof)) = cast(size_t)(_payload636.velocity.length); + *cast(void**)(_retArea.ptr + (72+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload636.velocity.ptr)); + if (_payload636.metadata.isSome) { + ref _payload640 = _payload636.metadata.unwrap(); + *cast(ubyte*)(_retArea.ptr + (72+3*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (72+5*size_t.sizeof)) = cast(size_t)(_payload640.length); + *cast(void**)(_retArea.ptr + (72+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload640.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (72+3*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag752.cSpawnPainting: { + const ref wit.pumpkin.plugin.java_packets.imports.CSpawnPainting _payload642 = packet.getCSpawnPainting(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(137); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload642.entityId)); + *cast(ulong*)(_retArea.ptr + 24) = cast(ulong)(_payload642.uuid.high); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(_payload642.uuid.low); + *cast(size_t*)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(size_t)(_payload642.title.length); + *cast(void**)(_retArea.ptr + 40) = cast(void*)(cast(void*)(_payload642.title.ptr)); + *cast(uint*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload642.variant)); + *cast(uint*)(_retArea.ptr + (44+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload642.location[0])); + *cast(uint*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload642.location[1])); + *cast(uint*)(_retArea.ptr + (52+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload642.location[2])); + *cast(ubyte*)(_retArea.ptr + (56+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload642.direction)); + break; + } + case _Tag752.cStartConfiguration: { + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(138); + break; + } + case _Tag752.cStopSound: { + const ref wit.pumpkin.plugin.java_packets.imports.CStopSound _payload646 = packet.getCStopSound(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(139); + if (_payload646.soundId.isSome) { + ref _payload650 = _payload646.soundId.unwrap(); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload650.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload650.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(0); + } + if (_payload646.category.isSome) { + ref _payload654 = _payload646.category.unwrap(); + *cast(ubyte*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (16+5*size_t.sizeof)) = cast(size_t)(_payload654.length); + *cast(void**)(_retArea.ptr + (16+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload654.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag752.cStoreCookie: { + const ref wit.pumpkin.plugin.java_packets.imports.CStoreCookie _payload656 = packet.getCStoreCookie(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(140); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload656.key.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload656.key.ptr)); + *cast(size_t*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(size_t)(_payload656.payload.length); + *cast(void**)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload656.payload.ptr)); + break; + } + case _Tag752.cSubtitle: { + const ref wit.pumpkin.plugin.java_packets.imports.CSubtitle _payload658 = packet.getCSubtitle(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(141); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload658.subtitle.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload658.subtitle.ptr)); + break; + } + case _Tag752.cTabList: { + const ref wit.pumpkin.plugin.java_packets.imports.CTabList _payload660 = packet.getCTabList(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(142); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload660.header.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload660.header.ptr)); + *cast(size_t*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(size_t)(_payload660.footer.length); + *cast(void**)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload660.footer.ptr)); + break; + } + case _Tag752.cTagQueryResponse: { + const ref wit.pumpkin.plugin.java_packets.imports.CTagQueryResponse _payload662 = packet.getCTagQueryResponse(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(143); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload662.transactionId)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload662.nbtBytes.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload662.nbtBytes.ptr)); + break; + } + case _Tag752.cTakeItemEntity: { + const ref wit.pumpkin.plugin.java_packets.imports.CTakeItemEntity _payload664 = packet.getCTakeItemEntity(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(144); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload664.entityId)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload664.collectorEntityId)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload664.stackAmount)); + break; + } + case _Tag752.cTeleportEntity: { + const ref wit.pumpkin.plugin.java_packets.imports.CTeleportEntity _payload666 = packet.getCTeleportEntity(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(145); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload666.entityId)); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload666.position[0]); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload666.position[1]); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload666.position[2]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload666.delta[0]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload666.delta[1]); + *cast(double*)(_retArea.ptr + 64) = cast(double)(_payload666.delta[2]); + *cast(float*)(_retArea.ptr + 72) = cast(float)(_payload666.yaw); + *cast(float*)(_retArea.ptr + 76) = cast(float)(_payload666.pitch); + auto _listSrc668 = _payload666.relatives; + auto _list668 = _listSrc668.length ? wit.common.malloc(_listSrc668.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc668.length || _list668); + if (_listSrc668.length) deallocate ~= _list668; + foreach (_elem667_idx, ref _elem667; _listSrc668) { + auto _base667 = _list668 + _elem667_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base667 + size_t.sizeof) = cast(size_t)(_elem667.length); + *cast(void**)(_base667 + 0) = cast(void*)(cast(void*)(_elem667.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (80+1*size_t.sizeof)) = cast(size_t)(_payload666.relatives.length); + *cast(void**)(_retArea.ptr + 80) = cast(void*)(_list668); + *cast(ubyte*)(_retArea.ptr + (80+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload666.onGround)); + break; + } + case _Tag752.cTestInstanceBlockStatus: { + const ref wit.pumpkin.plugin.java_packets.imports.CTestInstanceBlockStatus _payload670 = packet.getCTestInstanceBlockStatus(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(146); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload670.pos[0])); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload670.pos[1])); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload670.pos[2])); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload670.status)); + if (_payload670.message.isSome) { + ref _payload674 = _payload670.message.unwrap(); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload674.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload674.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(0); + } + break; + } + case _Tag752.cTickingState: { + const ref wit.pumpkin.plugin.java_packets.imports.CTickingState _payload676 = packet.getCTickingState(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(147); + *cast(float*)(_retArea.ptr + 16) = cast(float)(_payload676.tickRate); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload676.isFrozen)); + break; + } + case _Tag752.cTickingStep: { + const ref wit.pumpkin.plugin.java_packets.imports.CTickingStep _payload678 = packet.getCTickingStep(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(148); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload678.tickSteps)); + break; + } + case _Tag752.cTransfer: { + const ref wit.pumpkin.plugin.java_packets.imports.CTransfer _payload680 = packet.getCTransfer(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(149); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload680.host.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload680.host.ptr)); + *cast(uint*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload680.port)); + break; + } + case _Tag752.cUnloadChunk: { + const ref wit.pumpkin.plugin.java_packets.imports.CUnloadChunk _payload682 = packet.getCUnloadChunk(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(150); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload682.x)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload682.z)); + break; + } + case _Tag752.cUpdateAdvancements: { + const ref wit.pumpkin.plugin.java_packets.imports.CUpdateAdvancements _payload684 = packet.getCUpdateAdvancements(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(151); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload684.reset)); + auto _listSrc686 = _payload684.added; + auto _list686 = _listSrc686.length ? wit.common.malloc(_listSrc686.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc686.length || _list686); + if (_listSrc686.length) deallocate ~= _list686; + foreach (_elem685_idx, ref _elem685; _listSrc686) { + auto _base685 = _list686 + _elem685_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base685 + size_t.sizeof) = cast(size_t)(_elem685.length); + *cast(void**)(_base685 + 0) = cast(void*)(cast(void*)(_elem685.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload684.added.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(_list686); + auto _listSrc688 = _payload684.removed; + auto _list688 = _listSrc688.length ? wit.common.malloc(_listSrc688.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc688.length || _list688); + if (_listSrc688.length) deallocate ~= _list688; + foreach (_elem687_idx, ref _elem687; _listSrc688) { + auto _base687 = _list688 + _elem687_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base687 + size_t.sizeof) = cast(size_t)(_elem687.length); + *cast(void**)(_base687 + 0) = cast(void*)(cast(void*)(_elem687.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+4*size_t.sizeof)) = cast(size_t)(_payload684.removed.length); + *cast(void**)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(void*)(_list688); + auto _listSrc690 = _payload684.progress; + auto _list690 = _listSrc690.length ? wit.common.malloc(_listSrc690.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc690.length || _list690); + if (_listSrc690.length) deallocate ~= _list690; + foreach (_elem689_idx, ref _elem689; _listSrc690) { + auto _base689 = _list690 + _elem689_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base689 + size_t.sizeof) = cast(size_t)(_elem689.length); + *cast(void**)(_base689 + 0) = cast(void*)(cast(void*)(_elem689.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+6*size_t.sizeof)) = cast(size_t)(_payload684.progress.length); + *cast(void**)(_retArea.ptr + (16+5*size_t.sizeof)) = cast(void*)(_list690); + *cast(ubyte*)(_retArea.ptr + (16+7*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload684.showAdvancements)); + break; + } + case _Tag752.cUpdateAttributes: { + const ref wit.pumpkin.plugin.java_packets.imports.CUpdateAttributes _payload692 = packet.getCUpdateAttributes(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(152); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload692.entityId)); + auto _listSrc696 = _payload692.properties; + auto _list696 = _listSrc696.length ? wit.common.malloc(_listSrc696.length * ((16+2*size_t.sizeof))) : null; + assert(!_listSrc696.length || _list696); + if (_listSrc696.length) deallocate ~= _list696; + foreach (_elem693_idx, ref _elem693; _listSrc696) { + auto _base693 = _list696 + _elem693_idx * ((16+2*size_t.sizeof)); + *cast(uint*)(_base693 + 0) = cast(uint)(cast(uint)(_elem693.id)); + *cast(double*)(_base693 + 8) = cast(double)(_elem693.value); + auto _listSrc695 = _elem693.modifiers; + auto _list695 = _listSrc695.length ? wit.common.malloc(_listSrc695.length * ((16+2*size_t.sizeof))) : null; + assert(!_listSrc695.length || _list695); + if (_listSrc695.length) deallocate ~= _list695; + foreach (_elem694_idx, ref _elem694; _listSrc695) { + auto _base694 = _list695 + _elem694_idx * ((16+2*size_t.sizeof)); + *cast(size_t*)(_base694 + size_t.sizeof) = cast(size_t)(_elem694.id.length); + *cast(void**)(_base694 + 0) = cast(void*)(cast(void*)(_elem694.id.ptr)); + *cast(double*)(_base694 + (2*size_t.sizeof)) = cast(double)(_elem694.amount); + *cast(ubyte*)(_base694 + (8+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem694.operation)); + + } + *cast(size_t*)(_base693 + (16+1*size_t.sizeof)) = cast(size_t)(_elem693.modifiers.length); + *cast(void**)(_base693 + 16) = cast(void*)(_list695); + + } + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload692.properties.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(_list696); + break; + } + case _Tag752.cUpdateEntityPos: { + const ref wit.pumpkin.plugin.java_packets.imports.CUpdateEntityPos _payload698 = packet.getCUpdateEntityPos(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(153); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload698.entityId)); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload698.delta[0]); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload698.delta[1]); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload698.delta[2]); + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(cast(uint)(_payload698.onGround)); + break; + } + case _Tag752.cUpdateEntityPosRot: { + const ref wit.pumpkin.plugin.java_packets.imports.CUpdateEntityPosRot _payload700 = packet.getCUpdateEntityPosRot(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(154); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload700.entityId)); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload700.delta[0]); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload700.delta[1]); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload700.delta[2]); + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(cast(uint)(_payload700.yaw)); + *cast(ubyte*)(_retArea.ptr + 49) = cast(ubyte)(cast(uint)(_payload700.pitch)); + *cast(ubyte*)(_retArea.ptr + 50) = cast(ubyte)(cast(uint)(_payload700.onGround)); + break; + } + case _Tag752.cUpdateEntityRot: { + const ref wit.pumpkin.plugin.java_packets.imports.CUpdateEntityRot _payload702 = packet.getCUpdateEntityRot(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(155); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload702.entityId)); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload702.yaw)); + *cast(ubyte*)(_retArea.ptr + 21) = cast(ubyte)(cast(uint)(_payload702.pitch)); + *cast(ubyte*)(_retArea.ptr + 22) = cast(ubyte)(cast(uint)(_payload702.onGround)); + break; + } + case _Tag752.cUpdateMobEffect: { + const ref wit.pumpkin.plugin.java_packets.imports.CUpdateMobEffect _payload704 = packet.getCUpdateMobEffect(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(156); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload704.entityId)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload704.effectId)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload704.amplifier)); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload704.duration)); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload704.flags)); + break; + } + case _Tag752.cUpdateObjectives: { + const ref wit.pumpkin.plugin.java_packets.imports.CUpdateObjectives _payload706 = packet.getCUpdateObjectives(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(157); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload706.objectiveName.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload706.objectiveName.ptr)); + *cast(ubyte*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload706.mode)); + *cast(size_t*)(_retArea.ptr + (16+4*size_t.sizeof)) = cast(size_t)(_payload706.displayName.length); + *cast(void**)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload706.displayName.ptr)); + *cast(uint*)(_retArea.ptr + (16+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload706.renderType)); + if (_payload706.numberFormat.isSome) { + ref _payload710 = _payload706.numberFormat.unwrap(); + *cast(ubyte*)(_retArea.ptr + (16+6*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (16+8*size_t.sizeof)) = cast(size_t)(_payload710.length); + *cast(void**)(_retArea.ptr + (16+7*size_t.sizeof)) = cast(void*)(cast(void*)(_payload710.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (16+6*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag752.cUpdateRecipes: { + const ref wit.pumpkin.plugin.java_packets.imports.CUpdateRecipes _payload712 = packet.getCUpdateRecipes(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(158); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload712.rawData.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload712.rawData.ptr)); + break; + } + case _Tag752.cUpdateScore: { + const ref wit.pumpkin.plugin.java_packets.imports.CUpdateScore _payload714 = packet.getCUpdateScore(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(159); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload714.entityName.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload714.entityName.ptr)); + *cast(size_t*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(size_t)(_payload714.objectiveName.length); + *cast(void**)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload714.objectiveName.ptr)); + *cast(uint*)(_retArea.ptr + (16+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload714.value)); + if (_payload714.displayName.isSome) { + ref _payload718 = _payload714.displayName.unwrap(); + *cast(ubyte*)(_retArea.ptr + (16+5*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (16+7*size_t.sizeof)) = cast(size_t)(_payload718.length); + *cast(void**)(_retArea.ptr + (16+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload718.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (16+5*size_t.sizeof)) = cast(ubyte)(0); + } + if (_payload714.numberFormat.isSome) { + ref _payload722 = _payload714.numberFormat.unwrap(); + *cast(ubyte*)(_retArea.ptr + (16+8*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (16+10*size_t.sizeof)) = cast(size_t)(_payload722.length); + *cast(void**)(_retArea.ptr + (16+9*size_t.sizeof)) = cast(void*)(cast(void*)(_payload722.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (16+8*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag752.cUseBed: { + const ref wit.pumpkin.plugin.java_packets.imports.CUseBed _payload724 = packet.getCUseBed(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(160); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload724.entityId)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload724.location[0])); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload724.location[1])); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload724.location[2])); + break; + } + case _Tag752.cWaypoint: { + const ref wit.pumpkin.plugin.java_packets.imports.CWaypoint _payload726 = packet.getCWaypoint(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(161); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload726.operation)); + *cast(ulong*)(_retArea.ptr + 24) = cast(ulong)(_payload726.waypoint.identifier.high); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(_payload726.waypoint.identifier.low); + if (_payload726.waypoint.icon.isSome) { + ref _payload730 = _payload726.waypoint.icon.unwrap(); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(1); + if (_payload730.style.isSome) { + ref _payload734 = _payload730.style.unwrap(); + *cast(ubyte*)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(size_t)(_payload734.length); + *cast(void**)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload734.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(uint*)(_retArea.ptr + (40+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload730.color)); + } else { + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(0); + } + alias _Tag743 = wit.pumpkin.plugin.java_packets.imports.WaypointTarget.Tag; + final switch (_payload726.waypoint.target.tag) { + case _Tag743.position: { + const ref Tuple!(int, int, int) _payload736 = _payload726.waypoint.target.getPosition(); + *cast(ubyte*)(_retArea.ptr + (40+5*size_t.sizeof)) = cast(ubyte)(0); + *cast(uint*)(_retArea.ptr + (44+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload736[0])); + *cast(uint*)(_retArea.ptr + (48+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload736[1])); + *cast(uint*)(_retArea.ptr + (52+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload736[2])); + break; + } + case _Tag743.chunk: { + const ref wit.pumpkin.plugin.java_packets.imports.WaypointTargetChunk _payload738 = _payload726.waypoint.target.getChunk(); + *cast(ubyte*)(_retArea.ptr + (40+5*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (44+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload738.x)); + *cast(uint*)(_retArea.ptr + (48+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload738.z)); + break; + } + case _Tag743.azimuth: { + const ref float _payload740 = _payload726.waypoint.target.getAzimuth(); + *cast(ubyte*)(_retArea.ptr + (40+5*size_t.sizeof)) = cast(ubyte)(2); + *cast(float*)(_retArea.ptr + (44+5*size_t.sizeof)) = cast(float)(_payload740); + break; + } + case _Tag743.empty: { + *cast(ubyte*)(_retArea.ptr + (40+5*size_t.sizeof)) = cast(ubyte)(3); + break; + } + } + break; + } + case _Tag752.cWorldEvent: { + const ref wit.pumpkin.plugin.java_packets.imports.CWorldEvent _payload745 = packet.getCWorldEvent(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(162); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload745.event)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload745.location[0])); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload745.location[1])); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload745.location[2])); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload745.data)); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(cast(uint)(_payload745.disableRelativeVolume)); + break; + } + case _Tag752.statusCPingResponse: { + const ref wit.pumpkin.plugin.java_packets.imports.StatusCPingResponse _payload747 = packet.getStatusCPingResponse(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(163); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(cast(ulong)(_payload747.payload)); + break; + } + case _Tag752.statusCStatusResponse: { + const ref wit.pumpkin.plugin.java_packets.imports.StatusCStatusResponse _payload749 = packet.getStatusCStatusResponse(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(164); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload749.jsonResponse.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload749.jsonResponse.ptr)); + break; + } + case _Tag752.unknown: { + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(165); + break; + } + } + __import_sendPacket(_retArea.ptr); + deallocate.purge(); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]java-player.send-packet") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:java_player.send_packet") + static private extern(C) void __import_sendPacket(void*) nothrow; + + /++ + Sends a custom payload packet (plugin message) to the player. + +/ + void sendCustomPayload(in WitString channel, in WitList!(ubyte) data) @trusted nothrow { + __import_sendCustomPayload(this.__handle, cast(void*)(channel.ptr), channel.length, cast(void*)(data.ptr), data.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]java-player.send-custom-payload") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:java_player.send_custom_payload") + static private extern(C) void __import_sendCustomPayload(uint, void*, size_t, void*, size_t) nothrow; + + /++ + Shows a dialog to the player. + +/ + void showDialog(in Dialog dialog) @trusted nothrow { + wit.common.DeallocateBuffer deallocate; + auto _listSrc6 = dialog.body_; + auto _list6 = _listSrc6.length ? wit.common.malloc(_listSrc6.length * (8)) : null; + assert(!_listSrc6.length || _list6); + if (_listSrc6.length) deallocate ~= _list6; + foreach (_elem0_idx, ref _elem0; _listSrc6) { + auto _base0 = _list6 + _elem0_idx * (8); + alias _Tag5 = wit.pumpkin.plugin.java_dialogs.imports.DialogBody.Tag; + final switch (_elem0.tag) { + case _Tag5.plainMessage: { + const ref wit.pumpkin.plugin.java_dialogs.imports.TextComponent _payload2 = _elem0.getPlainMessage(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(0); + *cast(uint*)(_base0 + 4) = cast(uint)(_payload2.__handle); + break; + } + case _Tag5.item: { + const ref wit.pumpkin.plugin.java_dialogs.imports.ItemStack _payload4 = _elem0.getItem(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(1); + *cast(uint*)(_base0 + 4) = cast(uint)(_payload4.__handle); + break; + } + } + + } + auto _listSrc21 = dialog.inputs; + auto _list21 = _listSrc21.length ? wit.common.malloc(_listSrc21.length * ((16+5*size_t.sizeof))) : null; + assert(!_listSrc21.length || _list21); + if (_listSrc21.length) deallocate ~= _list21; + foreach (_elem7_idx, ref _elem7; _listSrc21) { + auto _base7 = _list21 + _elem7_idx * ((16+5*size_t.sizeof)); + alias _Tag20 = wit.pumpkin.plugin.java_dialogs.imports.DialogInput.Tag; + final switch (_elem7.tag) { + case _Tag20.bool_: { + const ref wit.pumpkin.plugin.java_dialogs.imports.DialogInputBool _payload9 = _elem7.getBool(); + *cast(ubyte*)(_base7 + 0) = cast(ubyte)(0); + *cast(uint*)(_base7 + size_t.sizeof) = cast(uint)(_payload9.label.__handle); + *cast(ubyte*)(_base7 + (4+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload9.defaultValue)); + break; + } + case _Tag20.text: { + const ref wit.pumpkin.plugin.java_dialogs.imports.DialogInputText _payload11 = _elem7.getText(); + *cast(ubyte*)(_base7 + 0) = cast(ubyte)(1); + *cast(uint*)(_base7 + size_t.sizeof) = cast(uint)(_payload11.label.__handle); + *cast(uint*)(_base7 + (4+1*size_t.sizeof)) = cast(uint)(_payload11.placeholder.__handle); + *cast(size_t*)(_base7 + (8+2*size_t.sizeof)) = cast(size_t)(_payload11.defaultValue.length); + *cast(void**)(_base7 + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload11.defaultValue.ptr)); + break; + } + case _Tag20.numberRange: { + const ref wit.pumpkin.plugin.java_dialogs.imports.DialogInputNumberRange _payload13 = _elem7.getNumberRange(); + *cast(ubyte*)(_base7 + 0) = cast(ubyte)(2); + *cast(uint*)(_base7 + size_t.sizeof) = cast(uint)(_payload13.label.__handle); + *cast(float*)(_base7 + (4+1*size_t.sizeof)) = cast(float)(_payload13.minValue); + *cast(float*)(_base7 + (8+1*size_t.sizeof)) = cast(float)(_payload13.maxValue); + *cast(float*)(_base7 + (12+1*size_t.sizeof)) = cast(float)(_payload13.initialValue); + *cast(float*)(_base7 + (16+1*size_t.sizeof)) = cast(float)(_payload13.step); + if (_payload13.labelFormat.isSome) { + ref _payload17 = _payload13.labelFormat.unwrap(); + *cast(ubyte*)(_base7 + (16+2*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_base7 + (16+4*size_t.sizeof)) = cast(size_t)(_payload17.length); + *cast(void**)(_base7 + (16+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload17.ptr)); + } else { + *cast(ubyte*)(_base7 + (16+2*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag20.singleOption: { + const ref wit.pumpkin.plugin.java_dialogs.imports.DialogInputSingleOption _payload19 = _elem7.getSingleOption(); + *cast(ubyte*)(_base7 + 0) = cast(ubyte)(3); + *cast(uint*)(_base7 + size_t.sizeof) = cast(uint)(_payload19.label.__handle); + *cast(size_t*)(_base7 + (3*size_t.sizeof)) = cast(size_t)(_payload19.options.length); + *cast(void**)(_base7 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload19.options.ptr)); + *cast(uint*)(_base7 + (4*size_t.sizeof)) = cast(uint)(_payload19.initialIndex); + break; + } + } + + } + auto _listSrc40 = dialog.buttons; + auto _list40 = _listSrc40.length ? wit.common.malloc(_listSrc40.length * ((16+7*size_t.sizeof))) : null; + assert(!_listSrc40.length || _list40); + if (_listSrc40.length) deallocate ~= _list40; + foreach (_elem22_idx, ref _elem22; _listSrc40) { + auto _base22 = _list40 + _elem22_idx * ((16+7*size_t.sizeof)); + *cast(uint*)(_base22 + 0) = cast(uint)(_elem22.text.__handle); + if (_elem22.tooltip.isSome) { + ref _payload26 = _elem22.tooltip.unwrap(); + *cast(ubyte*)(_base22 + 4) = cast(ubyte)(1); + *cast(uint*)(_base22 + 8) = cast(uint)(_payload26.__handle); + } else { + *cast(ubyte*)(_base22 + 4) = cast(ubyte)(0); + } + if (_elem22.width.isSome) { + ref _payload30 = _elem22.width.unwrap(); + *cast(ubyte*)(_base22 + 12) = cast(ubyte)(1); + *cast(uint*)(_base22 + 16) = cast(uint)(_payload30); + } else { + *cast(ubyte*)(_base22 + 12) = cast(ubyte)(0); + } + alias _Tag39 = wit.pumpkin.plugin.java_dialogs.imports.Action.Tag; + final switch (_elem22.action.tag) { + case _Tag39.openUrl: { + const ref WitString _payload32 = _elem22.action.getOpenUrl(); + *cast(ubyte*)(_base22 + (16+1*size_t.sizeof)) = cast(ubyte)(0); + *cast(size_t*)(_base22 + (16+3*size_t.sizeof)) = cast(size_t)(_payload32.length); + *cast(void**)(_base22 + (16+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload32.ptr)); + break; + } + case _Tag39.customClick: { + const ref wit.pumpkin.plugin.java_dialogs.imports.CustomClickAction _payload34 = _elem22.action.getCustomClick(); + *cast(ubyte*)(_base22 + (16+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_base22 + (16+3*size_t.sizeof)) = cast(size_t)(_payload34.id.length); + *cast(void**)(_base22 + (16+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload34.id.ptr)); + if (_payload34.payload.isSome) { + ref _payload38 = _payload34.payload.unwrap(); + *cast(ubyte*)(_base22 + (16+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_base22 + (16+6*size_t.sizeof)) = cast(size_t)(_payload38.length); + *cast(void**)(_base22 + (16+5*size_t.sizeof)) = cast(void*)(cast(void*)(_payload38.ptr)); + } else { + *cast(ubyte*)(_base22 + (16+4*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + } + + } + auto _listSrc47 = dialog.links; + auto _list47 = _listSrc47.length ? wit.common.malloc(_listSrc47.length * ((8+2*size_t.sizeof))) : null; + assert(!_listSrc47.length || _list47); + if (_listSrc47.length) deallocate ~= _list47; + foreach (_elem41_idx, ref _elem41; _listSrc47) { + auto _base41 = _list47 + _elem41_idx * ((8+2*size_t.sizeof)); + alias _Tag46 = wit.pumpkin.plugin.java_dialogs.imports.LinkLabel.Tag; + final switch (_elem41.label.tag) { + case _Tag46.builtIn: { + const ref wit.pumpkin.plugin.java_dialogs.imports.LinkType _payload43 = _elem41.label.getBuiltIn(); + *cast(ubyte*)(_base41 + 0) = cast(ubyte)(0); + *cast(ubyte*)(_base41 + 4) = cast(ubyte)(cast(uint)(_payload43)); + break; + } + case _Tag46.custom: { + const ref wit.pumpkin.plugin.java_dialogs.imports.TextComponent _payload45 = _elem41.label.getCustom(); + *cast(ubyte*)(_base41 + 0) = cast(ubyte)(1); + *cast(uint*)(_base41 + 4) = cast(uint)(_payload45.__handle); + break; + } + } + *cast(size_t*)(_base41 + (8+1*size_t.sizeof)) = cast(size_t)(_elem41.url.length); + *cast(void**)(_base41 + 8) = cast(void*)(cast(void*)(_elem41.url.ptr)); + + } + uint _option52 = void; + uint _option53 = void; + if (dialog.afterAction.isSome) { + ref _payload51 = dialog.afterAction.unwrap(); + _option52 = 1; + _option53 = cast(uint)(_payload51); + } else { + _option52 = 0; + _option53 = 0; + } + uint _option58 = void; + uint _option59 = void; + if (dialog.externalTitle.isSome) { + ref _payload57 = dialog.externalTitle.unwrap(); + _option58 = 1; + _option59 = _payload57.__handle; + } else { + _option58 = 0; + _option59 = 0; + } + __import_showDialog(this.__handle, dialog.title.__handle, cast(uint)(dialog.type), _list6, dialog.body_.length, _list21, dialog.inputs.length, _list40, dialog.buttons.length, _list47, dialog.links.length, _option52, _option53, cast(uint)(dialog.canCloseWithEscape), _option58, _option59); + deallocate.purge(); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]java-player.show-dialog") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:java_player.show_dialog") + static private extern(C) void __import_showDialog(uint, uint, uint, void*, size_t, void*, size_t, void*, size_t, void*, size_t, uint, uint, uint, uint, uint) nothrow; + + /++ + Clears any currently shown dialog for the player. + +/ + void clearDialog() @trusted nothrow { + __import_clearDialog(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]java-player.clear-dialog") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:java_player.clear_dialog") + static private extern(C) void __import_clearDialog(uint) nothrow; + + /++ + Returns the Java scoreboard handle for this player. + +/ + Scoreboard getScoreboard() @trusted nothrow { + auto _ret = __import_getScoreboard(this.__handle); + auto _handle0 = Scoreboard(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]java-player.get-scoreboard") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:java_player.get_scoreboard") + static private extern(C) uint __import_getScoreboard(uint) nothrow; + + /++ + Resets the player's custom Java scoreboard back to the world scoreboard. + +/ + void resetScoreboard() @trusted nothrow { + __import_resetScoreboard(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]java-player.reset-scoreboard") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:java_player.reset_scoreboard") + static private extern(C) void __import_resetScoreboard(uint) nothrow; + + /++ + Sends a resource pack to the Java player. + +/ + void sendResourcePack(in JavaResourcePack pack) @trusted nothrow { + uint _option4 = void; + uint _option5 = void; + if (pack.promptMessage.isSome) { + ref _payload3 = pack.promptMessage.unwrap(); + _option4 = 1; + _option5 = _payload3.__handle; + } else { + _option4 = 0; + _option5 = 0; + } + __import_sendResourcePack(this.__handle, pack.id.high, pack.id.low, cast(void*)(pack.url.ptr), pack.url.length, cast(void*)(pack.hash.ptr), pack.hash.length, cast(uint)(pack.forced), _option4, _option5); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]java-player.send-resource-pack") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:java_player.send_resource_pack") + static private extern(C) void __import_sendResourcePack(uint, ulong, ulong, void*, size_t, void*, size_t, uint, uint, uint) nothrow; + + /++ + Removes a specific resource pack by UUID for the Java player. + +/ + void removeResourcePack(in Uuid id) @trusted nothrow { + __import_removeResourcePack(this.__handle, id.high, id.low); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]java-player.remove-resource-pack") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:java_player.remove_resource_pack") + static private extern(C) void __import_removeResourcePack(uint, ulong, ulong) nothrow; + + /++ + Clears all custom resource packs for the Java player. + +/ + void clearResourcePacks() @trusted nothrow { + __import_clearResourcePacks(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]java-player.clear-resource-packs") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:java_player.clear_resource_packs") + static private extern(C) void __import_clearResourcePacks(uint) nothrow; + + /++ + Kicks the Java player with the specified options. + +/ + void kick(in JavaKickOptions options) @trusted nothrow { + __import_kick(this.__handle, options.reason.__handle, cast(uint)(options.logToConsole), cast(uint)(options.teardownPolicy)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]java-player.kick") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:java_player.kick") + static private extern(C) void __import_kick(uint, uint, uint, uint) nothrow; + + /++ + Sends a clientbound GameEvent packet to the Java player. + +/ + void sendGameEvent(ClientGameEvent event, float value) @trusted nothrow { + __import_sendGameEvent(this.__handle, cast(uint)(event), value); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]java-player.send-game-event") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:java_player.send_game_event") + static private extern(C) void __import_sendGameEvent(uint, uint, float) nothrow; + + /++ + Sends an entity status / animation event packet to the Java player for a specific entity ID. + +/ + void sendEntityStatus(int entityId, EntityStatus status) @trusted nothrow { + __import_sendEntityStatus(this.__handle, cast(uint)(entityId), cast(uint)(status)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]java-player.send-entity-status") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:java_player.send_entity_status") + static private extern(C) void __import_sendEntityStatus(uint, uint, uint) nothrow; + } +} + +/++ +A handle to a player connected via the Bedrock Edition. ++/ +struct BedrockPlayer { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/player@0.1.0", "[resource-drop]bedrock-player") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:resource_drop:bedrock_player") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + Returns the Minecraft Bedrock Edition version of the player. + +/ + BedrockMinecraftVersion getVersion() @trusted nothrow { + auto _ret = __import_getVersion(this.__handle); + return cast(BedrockMinecraftVersion)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]bedrock-player.get-version") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:bedrock_player.get_version") + static private extern(C) uint __import_getVersion(uint) nothrow; + + /++ + Returns the player's configuration settings. + +/ + BedrockPlayerSettings getSettings() @trusted nothrow { + align(8) void[(48+18*size_t.sizeof)] _retArea = void; + __import_getSettings(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _len2 = *(cast(size_t*)(_retArea.ptr + (4*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + (3*size_t.sizeof)))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + auto _len4 = *(cast(size_t*)(_retArea.ptr + (6*size_t.sizeof))); + auto _ptr4 = _len4 ? cast(char*)(*(cast(void**)(_retArea.ptr + (5*size_t.sizeof)))) : null; + auto _list5 = WitString(_ptr4[0.._len4]); + auto _len6 = *(cast(size_t*)(_retArea.ptr + (8*size_t.sizeof))); + auto _ptr6 = _len6 ? cast(char*)(*(cast(void**)(_retArea.ptr + (7*size_t.sizeof)))) : null; + auto _list7 = WitString(_ptr6[0.._len6]); + auto _len8 = *(cast(size_t*)(_retArea.ptr + (24+10*size_t.sizeof))); + auto _ptr8 = _len8 ? cast(char*)(*(cast(void**)(_retArea.ptr + (24+9*size_t.sizeof)))) : null; + auto _list9 = WitString(_ptr8[0.._len8]); + auto _len10 = *(cast(size_t*)(_retArea.ptr + (40+11*size_t.sizeof))); + auto _ptr10 = _len10 ? cast(char*)(*(cast(void**)(_retArea.ptr + (40+10*size_t.sizeof)))) : null; + auto _list11 = WitString(_ptr10[0.._len10]); + auto _len12 = *(cast(size_t*)(_retArea.ptr + (40+13*size_t.sizeof))); + auto _ptr12 = _len12 ? cast(char*)(*(cast(void**)(_retArea.ptr + (40+12*size_t.sizeof)))) : null; + auto _list13 = WitString(_ptr12[0.._len12]); + auto _len14 = *(cast(size_t*)(_retArea.ptr + (40+15*size_t.sizeof))); + auto _ptr14 = _len14 ? cast(char*)(*(cast(void**)(_retArea.ptr + (40+14*size_t.sizeof)))) : null; + auto _list15 = WitString(_ptr14[0.._len14]); + auto _len16 = *(cast(size_t*)(_retArea.ptr + (40+17*size_t.sizeof))); + auto _ptr16 = _len16 ? cast(char*)(*(cast(void**)(_retArea.ptr + (40+16*size_t.sizeof)))) : null; + auto _list17 = WitString(_ptr16[0.._len16]); + BedrockPlayerSettings _record18 = { + gameVersion: _list1, + deviceOs: cast(BedrockDeviceOs)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (2*size_t.sizeof))))), + deviceId: _list3, + deviceModel: _list5, + languageCode: _list7, + currentInputMode: cast(BedrockInputMode)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (9*size_t.sizeof))))), + defaultInputMode: cast(BedrockInputMode)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (1+9*size_t.sizeof))))), + uiProfile: cast(BedrockUiProfile)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (2+9*size_t.sizeof))))), + guiScale: cast(int)(*(cast(uint*)(_retArea.ptr + (4+9*size_t.sizeof)))), + isEditorMode: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (8+9*size_t.sizeof))))) != 0, + maxViewDistance: cast(int)(*(cast(uint*)(_retArea.ptr + (12+9*size_t.sizeof)))), + memoryTier: cast(int)(*(cast(uint*)(_retArea.ptr + (16+9*size_t.sizeof)))), + graphicsMode: cast(BedrockGraphicsMode)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (20+9*size_t.sizeof))))), + playfabId: _list9, + clientRandomId: cast(long)(*(cast(ulong*)(_retArea.ptr + (32+10*size_t.sizeof)))), + platformOfflineId: _list11, + platformOnlineId: _list13, + skinId: _list15, + armSize: _list17, + isPersonaSkin: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (40+18*size_t.sizeof))))) != 0, + isPremiumSkin: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (41+18*size_t.sizeof))))) != 0, + isTrustedSkin: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (42+18*size_t.sizeof))))) != 0, + }; + auto _flush19 = _record18; + return _flush19; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]bedrock-player.get-settings") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:bedrock_player.get_settings") + static private extern(C) void __import_getSettings(uint, void*) nothrow; + + /++ + Returns whether a specific Bedrock-only ability is enabled for the player. + +/ + bool getAbility(BedrockAbility ability) @trusted nothrow { + auto _ret = __import_getAbility(this.__handle, cast(uint)(ability)); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]bedrock-player.get-ability") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:bedrock_player.get_ability") + static private extern(C) uint __import_getAbility(uint, uint) nothrow; + + /++ + Sets whether a specific Bedrock-only ability is enabled for the player. + +/ + void setAbility(BedrockAbility ability, bool value) @trusted nothrow { + __import_setAbility(this.__handle, cast(uint)(ability), cast(uint)(value)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]bedrock-player.set-ability") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:bedrock_player.set_ability") + static private extern(C) void __import_setAbility(uint, uint, uint) nothrow; + + /++ + Returns whether a specific Bedrock-only status flag is enabled for the player. + + Status flags control things like whether the player is on fire, sneaking, + sprinting, or has specific visual effects. + +/ + bool getStatusFlag(BedrockStatusFlag flag) @trusted nothrow { + auto _ret = __import_getStatusFlag(this.__handle, cast(uint)(flag)); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]bedrock-player.get-status-flag") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:bedrock_player.get_status_flag") + static private extern(C) uint __import_getStatusFlag(uint, uint) nothrow; + + /++ + Sets whether a specific Bedrock-only status flag is enabled for the player. + + This can be used to manually trigger client-side visual states. + +/ + void setStatusFlag(BedrockStatusFlag flag, bool value) @trusted nothrow { + __import_setStatusFlag(this.__handle, cast(uint)(flag), cast(uint)(value)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]bedrock-player.set-status-flag") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:bedrock_player.set_status_flag") + static private extern(C) void __import_setStatusFlag(uint, uint, uint) nothrow; + + /++ + Sends a Bedrock-specific clientbound packet to the player. + +/ + void sendPacket(in BedrockPacket packet) @trusted nothrow { + align(8) void[(328+58*size_t.sizeof)] _retArea = void; + wit.common.DeallocateBuffer deallocate; + *cast(uint*)(_retArea.ptr + 0) = cast(uint)(this.__handle); + alias _Tag301 = wit.pumpkin.plugin.bedrock_packets.imports.ClientboundPacket.Tag; + final switch (packet.tag) { + case _Tag301.cAddActor: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CAddActor _payload1 = packet.getCAddActor(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(0); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(cast(ulong)(_payload1.targetActorId)); + *cast(ulong*)(_retArea.ptr + 24) = cast(ulong)(cast(ulong)(_payload1.targetRuntimeId)); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload1.actorType.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload1.actorType.ptr)); + *cast(double*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(double)(_payload1.position[0]); + *cast(double*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(double)(_payload1.position[1]); + *cast(double*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(double)(_payload1.position[2]); + *cast(double*)(_retArea.ptr + (56+2*size_t.sizeof)) = cast(double)(_payload1.velocity[0]); + *cast(double*)(_retArea.ptr + (64+2*size_t.sizeof)) = cast(double)(_payload1.velocity[1]); + *cast(double*)(_retArea.ptr + (72+2*size_t.sizeof)) = cast(double)(_payload1.velocity[2]); + *cast(double*)(_retArea.ptr + (80+2*size_t.sizeof)) = cast(double)(_payload1.rotation[0]); + *cast(double*)(_retArea.ptr + (88+2*size_t.sizeof)) = cast(double)(_payload1.rotation[1]); + *cast(float*)(_retArea.ptr + (96+2*size_t.sizeof)) = cast(float)(_payload1.yHeadRotation); + *cast(float*)(_retArea.ptr + (100+2*size_t.sizeof)) = cast(float)(_payload1.yBodyRotation); + auto _listSrc3 = _payload1.attributesList; + auto _list3 = _listSrc3.length ? wit.common.malloc(_listSrc3.length * ((8+3*size_t.sizeof))) : null; + assert(!_listSrc3.length || _list3); + if (_listSrc3.length) deallocate ~= _list3; + foreach (_elem2_idx, ref _elem2; _listSrc3) { + auto _base2 = _list3 + _elem2_idx * ((8+3*size_t.sizeof)); + *cast(size_t*)(_base2 + size_t.sizeof) = cast(size_t)(_elem2.attributeName.length); + *cast(void**)(_base2 + 0) = cast(void*)(cast(void*)(_elem2.attributeName.ptr)); + *cast(float*)(_base2 + (2*size_t.sizeof)) = cast(float)(_elem2.minValue); + *cast(float*)(_base2 + (4+2*size_t.sizeof)) = cast(float)(_elem2.currentValue); + *cast(float*)(_base2 + (8+2*size_t.sizeof)) = cast(float)(_elem2.maxValue); + + } + *cast(size_t*)(_retArea.ptr + (104+3*size_t.sizeof)) = cast(size_t)(_payload1.attributesList.length); + *cast(void**)(_retArea.ptr + (104+2*size_t.sizeof)) = cast(void*)(_list3); + *cast(size_t*)(_retArea.ptr + (104+5*size_t.sizeof)) = cast(size_t)(_payload1.actorData.length); + *cast(void**)(_retArea.ptr + (104+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload1.actorData.ptr)); + *cast(size_t*)(_retArea.ptr + (104+7*size_t.sizeof)) = cast(size_t)(_payload1.syncedProperties.intEntriesList.length); + *cast(void**)(_retArea.ptr + (104+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload1.syncedProperties.intEntriesList.ptr)); + *cast(size_t*)(_retArea.ptr + (104+9*size_t.sizeof)) = cast(size_t)(_payload1.syncedProperties.floatEntriesList.length); + *cast(void**)(_retArea.ptr + (104+8*size_t.sizeof)) = cast(void*)(cast(void*)(_payload1.syncedProperties.floatEntriesList.ptr)); + auto _listSrc5 = _payload1.actorLinks; + auto _list5 = _listSrc5.length ? wit.common.malloc(_listSrc5.length * (24)) : null; + assert(!_listSrc5.length || _list5); + if (_listSrc5.length) deallocate ~= _list5; + foreach (_elem4_idx, ref _elem4; _listSrc5) { + auto _base4 = _list5 + _elem4_idx * (24); + *cast(ulong*)(_base4 + 0) = cast(ulong)(cast(ulong)(_elem4.riddenUniqueId)); + *cast(ulong*)(_base4 + 8) = cast(ulong)(cast(ulong)(_elem4.riderUniqueId)); + *cast(ubyte*)(_base4 + 16) = cast(ubyte)(cast(uint)(_elem4.linkType)); + *cast(ubyte*)(_base4 + 17) = cast(ubyte)(cast(uint)(_elem4.immediate)); + *cast(ubyte*)(_base4 + 18) = cast(ubyte)(cast(uint)(_elem4.riderInitiated)); + *cast(float*)(_base4 + 20) = cast(float)(_elem4.vehicleAngularVelocity); + + } + *cast(size_t*)(_retArea.ptr + (104+11*size_t.sizeof)) = cast(size_t)(_payload1.actorLinks.length); + *cast(void**)(_retArea.ptr + (104+10*size_t.sizeof)) = cast(void*)(_list5); + break; + } + case _Tag301.cAddItemActor: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CAddItemActor _payload7 = packet.getCAddItemActor(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(1); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(cast(ulong)(_payload7.targetActorId)); + *cast(ulong*)(_retArea.ptr + 24) = cast(ulong)(cast(ulong)(_payload7.targetRuntimeId)); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload7.item.id)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload7.item.stackSize)); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload7.item.auxValue)); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload7.item.blockRuntimeId)); + *cast(size_t*)(_retArea.ptr + (48+1*size_t.sizeof)) = cast(size_t)(_payload7.item.nbtData.length); + *cast(void**)(_retArea.ptr + 48) = cast(void*)(cast(void*)(_payload7.item.nbtData.ptr)); + auto _listSrc9 = _payload7.item.placeOnBlocks; + auto _list9 = _listSrc9.length ? wit.common.malloc(_listSrc9.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc9.length || _list9); + if (_listSrc9.length) deallocate ~= _list9; + foreach (_elem8_idx, ref _elem8; _listSrc9) { + auto _base8 = _list9 + _elem8_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base8 + size_t.sizeof) = cast(size_t)(_elem8.length); + *cast(void**)(_base8 + 0) = cast(void*)(cast(void*)(_elem8.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (48+3*size_t.sizeof)) = cast(size_t)(_payload7.item.placeOnBlocks.length); + *cast(void**)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(void*)(_list9); + auto _listSrc11 = _payload7.item.destroyBlocks; + auto _list11 = _listSrc11.length ? wit.common.malloc(_listSrc11.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc11.length || _list11); + if (_listSrc11.length) deallocate ~= _list11; + foreach (_elem10_idx, ref _elem10; _listSrc11) { + auto _base10 = _list11 + _elem10_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base10 + size_t.sizeof) = cast(size_t)(_elem10.length); + *cast(void**)(_base10 + 0) = cast(void*)(cast(void*)(_elem10.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (48+5*size_t.sizeof)) = cast(size_t)(_payload7.item.destroyBlocks.length); + *cast(void**)(_retArea.ptr + (48+4*size_t.sizeof)) = cast(void*)(_list11); + *cast(ulong*)(_retArea.ptr + (48+6*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload7.item.shieldBlockingTick)); + if (_payload7.item.netId.isSome) { + ref _payload15 = _payload7.item.netId.unwrap(); + *cast(ubyte*)(_retArea.ptr + (56+6*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (60+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload15)); + } else { + *cast(ubyte*)(_retArea.ptr + (56+6*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(double*)(_retArea.ptr + (64+6*size_t.sizeof)) = cast(double)(_payload7.position[0]); + *cast(double*)(_retArea.ptr + (72+6*size_t.sizeof)) = cast(double)(_payload7.position[1]); + *cast(double*)(_retArea.ptr + (80+6*size_t.sizeof)) = cast(double)(_payload7.position[2]); + *cast(double*)(_retArea.ptr + (88+6*size_t.sizeof)) = cast(double)(_payload7.velocity[0]); + *cast(double*)(_retArea.ptr + (96+6*size_t.sizeof)) = cast(double)(_payload7.velocity[1]); + *cast(double*)(_retArea.ptr + (104+6*size_t.sizeof)) = cast(double)(_payload7.velocity[2]); + *cast(size_t*)(_retArea.ptr + (112+7*size_t.sizeof)) = cast(size_t)(_payload7.entityData.length); + *cast(void**)(_retArea.ptr + (112+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7.entityData.ptr)); + *cast(ubyte*)(_retArea.ptr + (112+8*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7.isFromFishing)); + break; + } + case _Tag301.cAddPlayer: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CAddPlayer _payload17 = packet.getCAddPlayer(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(2); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(_payload17.uuid.high); + *cast(ulong*)(_retArea.ptr + 24) = cast(ulong)(_payload17.uuid.low); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload17.playerName.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload17.playerName.ptr)); + *cast(ulong*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload17.targetRuntimeId)); + *cast(size_t*)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(size_t)(_payload17.platformChatId.length); + *cast(void**)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload17.platformChatId.ptr)); + *cast(double*)(_retArea.ptr + (40+4*size_t.sizeof)) = cast(double)(_payload17.position[0]); + *cast(double*)(_retArea.ptr + (48+4*size_t.sizeof)) = cast(double)(_payload17.position[1]); + *cast(double*)(_retArea.ptr + (56+4*size_t.sizeof)) = cast(double)(_payload17.position[2]); + *cast(double*)(_retArea.ptr + (64+4*size_t.sizeof)) = cast(double)(_payload17.velocity[0]); + *cast(double*)(_retArea.ptr + (72+4*size_t.sizeof)) = cast(double)(_payload17.velocity[1]); + *cast(double*)(_retArea.ptr + (80+4*size_t.sizeof)) = cast(double)(_payload17.velocity[2]); + *cast(double*)(_retArea.ptr + (88+4*size_t.sizeof)) = cast(double)(_payload17.rotation[0]); + *cast(double*)(_retArea.ptr + (96+4*size_t.sizeof)) = cast(double)(_payload17.rotation[1]); + *cast(float*)(_retArea.ptr + (104+4*size_t.sizeof)) = cast(float)(_payload17.yHeadRotation); + *cast(uint*)(_retArea.ptr + (104+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload17.carriedItem.id)); + *cast(uint*)(_retArea.ptr + (108+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload17.carriedItem.stackSize)); + *cast(uint*)(_retArea.ptr + (112+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload17.carriedItem.auxValue)); + *cast(uint*)(_retArea.ptr + (116+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload17.carriedItem.blockRuntimeId)); + *cast(size_t*)(_retArea.ptr + (120+6*size_t.sizeof)) = cast(size_t)(_payload17.carriedItem.extraData.length); + *cast(void**)(_retArea.ptr + (120+5*size_t.sizeof)) = cast(void*)(cast(void*)(_payload17.carriedItem.extraData.ptr)); + if (_payload17.carriedItem.netId.isSome) { + ref _payload21 = _payload17.carriedItem.netId.unwrap(); + *cast(ubyte*)(_retArea.ptr + (120+7*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (124+7*size_t.sizeof)) = cast(uint)(cast(uint)(_payload21)); + } else { + *cast(ubyte*)(_retArea.ptr + (120+7*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + (128+7*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload17.playerGameType)); + *cast(size_t*)(_retArea.ptr + (128+9*size_t.sizeof)) = cast(size_t)(_payload17.entityData.length); + *cast(void**)(_retArea.ptr + (128+8*size_t.sizeof)) = cast(void*)(cast(void*)(_payload17.entityData.ptr)); + *cast(size_t*)(_retArea.ptr + (128+11*size_t.sizeof)) = cast(size_t)(_payload17.syncedProperties.intEntriesList.length); + *cast(void**)(_retArea.ptr + (128+10*size_t.sizeof)) = cast(void*)(cast(void*)(_payload17.syncedProperties.intEntriesList.ptr)); + *cast(size_t*)(_retArea.ptr + (128+13*size_t.sizeof)) = cast(size_t)(_payload17.syncedProperties.floatEntriesList.length); + *cast(void**)(_retArea.ptr + (128+12*size_t.sizeof)) = cast(void*)(cast(void*)(_payload17.syncedProperties.floatEntriesList.ptr)); + *cast(ulong*)(_retArea.ptr + (128+14*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload17.abilitiesData.targetPlayerRawId)); + *cast(ubyte*)(_retArea.ptr + (136+14*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload17.abilitiesData.playerPermissions)); + *cast(ubyte*)(_retArea.ptr + (137+14*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload17.abilitiesData.commandPermissions)); + *cast(size_t*)(_retArea.ptr + (136+16*size_t.sizeof)) = cast(size_t)(_payload17.abilitiesData.layers.length); + *cast(void**)(_retArea.ptr + (136+15*size_t.sizeof)) = cast(void*)(cast(void*)(_payload17.abilitiesData.layers.ptr)); + auto _listSrc23 = _payload17.actorLinks; + auto _list23 = _listSrc23.length ? wit.common.malloc(_listSrc23.length * (24)) : null; + assert(!_listSrc23.length || _list23); + if (_listSrc23.length) deallocate ~= _list23; + foreach (_elem22_idx, ref _elem22; _listSrc23) { + auto _base22 = _list23 + _elem22_idx * (24); + *cast(ulong*)(_base22 + 0) = cast(ulong)(cast(ulong)(_elem22.riddenUniqueId)); + *cast(ulong*)(_base22 + 8) = cast(ulong)(cast(ulong)(_elem22.riderUniqueId)); + *cast(ubyte*)(_base22 + 16) = cast(ubyte)(cast(uint)(_elem22.linkType)); + *cast(ubyte*)(_base22 + 17) = cast(ubyte)(cast(uint)(_elem22.immediate)); + *cast(ubyte*)(_base22 + 18) = cast(ubyte)(cast(uint)(_elem22.riderInitiated)); + *cast(float*)(_base22 + 20) = cast(float)(_elem22.vehicleAngularVelocity); + + } + *cast(size_t*)(_retArea.ptr + (144+17*size_t.sizeof)) = cast(size_t)(_payload17.actorLinks.length); + *cast(void**)(_retArea.ptr + (144+16*size_t.sizeof)) = cast(void*)(_list23); + *cast(size_t*)(_retArea.ptr + (144+19*size_t.sizeof)) = cast(size_t)(_payload17.deviceId.length); + *cast(void**)(_retArea.ptr + (144+18*size_t.sizeof)) = cast(void*)(cast(void*)(_payload17.deviceId.ptr)); + *cast(ubyte*)(_retArea.ptr + (144+20*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload17.buildPlatform)); + break; + } + case _Tag301.cAvailableCommands: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CAvailableCommands _payload25 = packet.getCAvailableCommands(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(3); + auto _listSrc27 = _payload25.enumValues; + auto _list27 = _listSrc27.length ? wit.common.malloc(_listSrc27.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc27.length || _list27); + if (_listSrc27.length) deallocate ~= _list27; + foreach (_elem26_idx, ref _elem26; _listSrc27) { + auto _base26 = _list27 + _elem26_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base26 + size_t.sizeof) = cast(size_t)(_elem26.length); + *cast(void**)(_base26 + 0) = cast(void*)(cast(void*)(_elem26.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload25.enumValues.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(_list27); + auto _listSrc29 = _payload25.chainedSubcommandValues; + auto _list29 = _listSrc29.length ? wit.common.malloc(_listSrc29.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc29.length || _list29); + if (_listSrc29.length) deallocate ~= _list29; + foreach (_elem28_idx, ref _elem28; _listSrc29) { + auto _base28 = _list29 + _elem28_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base28 + size_t.sizeof) = cast(size_t)(_elem28.length); + *cast(void**)(_base28 + 0) = cast(void*)(cast(void*)(_elem28.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(size_t)(_payload25.chainedSubcommandValues.length); + *cast(void**)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(void*)(_list29); + auto _listSrc31 = _payload25.postFixes; + auto _list31 = _listSrc31.length ? wit.common.malloc(_listSrc31.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc31.length || _list31); + if (_listSrc31.length) deallocate ~= _list31; + foreach (_elem30_idx, ref _elem30; _listSrc31) { + auto _base30 = _list31 + _elem30_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base30 + size_t.sizeof) = cast(size_t)(_elem30.length); + *cast(void**)(_base30 + 0) = cast(void*)(cast(void*)(_elem30.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+5*size_t.sizeof)) = cast(size_t)(_payload25.postFixes.length); + *cast(void**)(_retArea.ptr + (16+4*size_t.sizeof)) = cast(void*)(_list31); + auto _listSrc33 = _payload25.enumData; + auto _list33 = _listSrc33.length ? wit.common.malloc(_listSrc33.length * ((4*size_t.sizeof))) : null; + assert(!_listSrc33.length || _list33); + if (_listSrc33.length) deallocate ~= _list33; + foreach (_elem32_idx, ref _elem32; _listSrc33) { + auto _base32 = _list33 + _elem32_idx * ((4*size_t.sizeof)); + *cast(size_t*)(_base32 + size_t.sizeof) = cast(size_t)(_elem32.name.length); + *cast(void**)(_base32 + 0) = cast(void*)(cast(void*)(_elem32.name.ptr)); + *cast(size_t*)(_base32 + (3*size_t.sizeof)) = cast(size_t)(_elem32.values.length); + *cast(void**)(_base32 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem32.values.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+7*size_t.sizeof)) = cast(size_t)(_payload25.enumData.length); + *cast(void**)(_retArea.ptr + (16+6*size_t.sizeof)) = cast(void*)(_list33); + auto _listSrc35 = _payload25.chainedSubcommandData; + auto _list35 = _listSrc35.length ? wit.common.malloc(_listSrc35.length * ((4*size_t.sizeof))) : null; + assert(!_listSrc35.length || _list35); + if (_listSrc35.length) deallocate ~= _list35; + foreach (_elem34_idx, ref _elem34; _listSrc35) { + auto _base34 = _list35 + _elem34_idx * ((4*size_t.sizeof)); + *cast(size_t*)(_base34 + size_t.sizeof) = cast(size_t)(_elem34.name.length); + *cast(void**)(_base34 + 0) = cast(void*)(cast(void*)(_elem34.name.ptr)); + *cast(size_t*)(_base34 + (3*size_t.sizeof)) = cast(size_t)(_elem34.subcommandValues.length); + *cast(void**)(_base34 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem34.subcommandValues.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+9*size_t.sizeof)) = cast(size_t)(_payload25.chainedSubcommandData.length); + *cast(void**)(_retArea.ptr + (16+8*size_t.sizeof)) = cast(void*)(_list35); + auto _listSrc41 = _payload25.commands; + auto _list41 = _listSrc41.length ? wit.common.malloc(_listSrc41.length * ((8+9*size_t.sizeof))) : null; + assert(!_listSrc41.length || _list41); + if (_listSrc41.length) deallocate ~= _list41; + foreach (_elem36_idx, ref _elem36; _listSrc41) { + auto _base36 = _list41 + _elem36_idx * ((8+9*size_t.sizeof)); + *cast(size_t*)(_base36 + size_t.sizeof) = cast(size_t)(_elem36.name.length); + *cast(void**)(_base36 + 0) = cast(void*)(cast(void*)(_elem36.name.ptr)); + *cast(size_t*)(_base36 + (3*size_t.sizeof)) = cast(size_t)(_elem36.description.length); + *cast(void**)(_base36 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem36.description.ptr)); + *cast(uint*)(_base36 + (4*size_t.sizeof)) = cast(uint)(cast(uint)(_elem36.flags)); + *cast(ubyte*)(_base36 + (4+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem36.permissionLevel)); + *cast(uint*)(_base36 + (8+4*size_t.sizeof)) = cast(uint)(cast(uint)(_elem36.aliasEnum)); + *cast(size_t*)(_base36 + (8+6*size_t.sizeof)) = cast(size_t)(_elem36.commandDataChainedSubcommandIndexes.length); + *cast(void**)(_base36 + (8+5*size_t.sizeof)) = cast(void*)(cast(void*)(_elem36.commandDataChainedSubcommandIndexes.ptr)); + auto _listSrc40 = _elem36.overloads; + auto _list40 = _listSrc40.length ? wit.common.malloc(_listSrc40.length * ((3*size_t.sizeof))) : null; + assert(!_listSrc40.length || _list40); + if (_listSrc40.length) deallocate ~= _list40; + foreach (_elem37_idx, ref _elem37; _listSrc40) { + auto _base37 = _list40 + _elem37_idx * ((3*size_t.sizeof)); + *cast(ubyte*)(_base37 + 0) = cast(ubyte)(cast(uint)(_elem37.isChaining)); + auto _listSrc39 = _elem37.parameterData; + auto _list39 = _listSrc39.length ? wit.common.malloc(_listSrc39.length * ((8+2*size_t.sizeof))) : null; + assert(!_listSrc39.length || _list39); + if (_listSrc39.length) deallocate ~= _list39; + foreach (_elem38_idx, ref _elem38; _listSrc39) { + auto _base38 = _list39 + _elem38_idx * ((8+2*size_t.sizeof)); + *cast(size_t*)(_base38 + size_t.sizeof) = cast(size_t)(_elem38.name.length); + *cast(void**)(_base38 + 0) = cast(void*)(cast(void*)(_elem38.name.ptr)); + *cast(uint*)(_base38 + (2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem38.parseSymbol)); + *cast(ubyte*)(_base38 + (4+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem38.isOptional)); + *cast(ubyte*)(_base38 + (5+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem38.options)); + + } + *cast(size_t*)(_base37 + (2*size_t.sizeof)) = cast(size_t)(_elem37.parameterData.length); + *cast(void**)(_base37 + size_t.sizeof) = cast(void*)(_list39); + + } + *cast(size_t*)(_base36 + (8+8*size_t.sizeof)) = cast(size_t)(_elem36.overloads.length); + *cast(void**)(_base36 + (8+7*size_t.sizeof)) = cast(void*)(_list40); + + } + *cast(size_t*)(_retArea.ptr + (16+11*size_t.sizeof)) = cast(size_t)(_payload25.commands.length); + *cast(void**)(_retArea.ptr + (16+10*size_t.sizeof)) = cast(void*)(_list41); + auto _listSrc45 = _payload25.softEnums; + auto _list45 = _listSrc45.length ? wit.common.malloc(_listSrc45.length * ((4*size_t.sizeof))) : null; + assert(!_listSrc45.length || _list45); + if (_listSrc45.length) deallocate ~= _list45; + foreach (_elem42_idx, ref _elem42; _listSrc45) { + auto _base42 = _list45 + _elem42_idx * ((4*size_t.sizeof)); + *cast(size_t*)(_base42 + size_t.sizeof) = cast(size_t)(_elem42.enumName.length); + *cast(void**)(_base42 + 0) = cast(void*)(cast(void*)(_elem42.enumName.ptr)); + auto _listSrc44 = _elem42.enumOptions; + auto _list44 = _listSrc44.length ? wit.common.malloc(_listSrc44.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc44.length || _list44); + if (_listSrc44.length) deallocate ~= _list44; + foreach (_elem43_idx, ref _elem43; _listSrc44) { + auto _base43 = _list44 + _elem43_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base43 + size_t.sizeof) = cast(size_t)(_elem43.length); + *cast(void**)(_base43 + 0) = cast(void*)(cast(void*)(_elem43.ptr)); + + } + *cast(size_t*)(_base42 + (3*size_t.sizeof)) = cast(size_t)(_elem42.enumOptions.length); + *cast(void**)(_base42 + (2*size_t.sizeof)) = cast(void*)(_list44); + + } + *cast(size_t*)(_retArea.ptr + (16+13*size_t.sizeof)) = cast(size_t)(_payload25.softEnums.length); + *cast(void**)(_retArea.ptr + (16+12*size_t.sizeof)) = cast(void*)(_list45); + auto _listSrc47 = _payload25.constraints; + auto _list47 = _listSrc47.length ? wit.common.malloc(_listSrc47.length * ((8+2*size_t.sizeof))) : null; + assert(!_listSrc47.length || _list47); + if (_listSrc47.length) deallocate ~= _list47; + foreach (_elem46_idx, ref _elem46; _listSrc47) { + auto _base46 = _list47 + _elem46_idx * ((8+2*size_t.sizeof)); + *cast(uint*)(_base46 + 0) = cast(uint)(cast(uint)(_elem46.enumValueSymbol)); + *cast(uint*)(_base46 + 4) = cast(uint)(cast(uint)(_elem46.enumSymbol)); + *cast(size_t*)(_base46 + (8+1*size_t.sizeof)) = cast(size_t)(_elem46.constraintIndices.length); + *cast(void**)(_base46 + 8) = cast(void*)(cast(void*)(_elem46.constraintIndices.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+15*size_t.sizeof)) = cast(size_t)(_payload25.constraints.length); + *cast(void**)(_retArea.ptr + (16+14*size_t.sizeof)) = cast(void*)(_list47); + break; + } + case _Tag301.cBiomeDefinitionList: { + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(4); + break; + } + case _Tag301.cBlockActorData: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CBlockActorData _payload51 = packet.getCBlockActorData(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(5); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload51.blockPosition[0])); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload51.blockPosition[1])); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload51.blockPosition[2])); + *cast(size_t*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(size_t)(_payload51.actorDataTags.length); + *cast(void**)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload51.actorDataTags.ptr)); + break; + } + case _Tag301.cBlockEvent: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CBlockEvent _payload53 = packet.getCBlockEvent(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(6); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload53.blockPosition[0])); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload53.blockPosition[1])); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload53.blockPosition[2])); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload53.eventType)); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload53.eventValue)); + break; + } + case _Tag301.cBossEvent: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CBossEvent _payload55 = packet.getCBossEvent(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(7); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(cast(ulong)(_payload55.bossEntityId)); + *cast(ulong*)(_retArea.ptr + 24) = cast(ulong)(cast(ulong)(_payload55.playerEntityId)); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload55.eventType)); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload55.title.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload55.title.ptr)); + *cast(size_t*)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(size_t)(_payload55.filteredTitle.length); + *cast(void**)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload55.filteredTitle.ptr)); + *cast(float*)(_retArea.ptr + (32+5*size_t.sizeof)) = cast(float)(_payload55.healthPercentage); + *cast(ubyte*)(_retArea.ptr + (36+5*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload55.color)); + *cast(ubyte*)(_retArea.ptr + (37+5*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload55.overlay)); + break; + } + case _Tag301.cChangeDimension: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CChangeDimension _payload57 = packet.getCChangeDimension(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(8); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload57.dimensionId)); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload57.position[0]); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload57.position[1]); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload57.position[2]); + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(cast(uint)(_payload57.respawn)); + if (_payload57.loadingScreenId.isSome) { + ref _payload61 = _payload57.loadingScreenId.unwrap(); + *cast(ubyte*)(_retArea.ptr + 52) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 56) = cast(uint)(cast(uint)(_payload61)); + } else { + *cast(ubyte*)(_retArea.ptr + 52) = cast(ubyte)(0); + } + break; + } + case _Tag301.cChunkRadiusUpdated: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CChunkRadiusUpdated _payload63 = packet.getCChunkRadiusUpdated(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(9); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload63.chunkRadius)); + break; + } + case _Tag301.cClientCacheMissResponse: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CClientCacheMissResponse _payload65 = packet.getCClientCacheMissResponse(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(10); + auto _listSrc67 = _payload65.missingBlobs; + auto _list67 = _listSrc67.length ? wit.common.malloc(_listSrc67.length * ((8+2*size_t.sizeof))) : null; + assert(!_listSrc67.length || _list67); + if (_listSrc67.length) deallocate ~= _list67; + foreach (_elem66_idx, ref _elem66; _listSrc67) { + auto _base66 = _list67 + _elem66_idx * ((8+2*size_t.sizeof)); + *cast(ulong*)(_base66 + 0) = cast(ulong)(cast(ulong)(_elem66.blobId)); + *cast(size_t*)(_base66 + (8+1*size_t.sizeof)) = cast(size_t)(_elem66.blobData.length); + *cast(void**)(_base66 + 8) = cast(void*)(cast(void*)(_elem66.blobData.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload65.missingBlobs.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(_list67); + break; + } + case _Tag301.cContainerOpen: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CContainerOpen _payload69 = packet.getCContainerOpen(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(11); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload69.containerId)); + *cast(ubyte*)(_retArea.ptr + 17) = cast(ubyte)(cast(uint)(_payload69.containerType)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload69.position[0])); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload69.position[1])); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload69.position[2])); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload69.targetEntityId)); + break; + } + case _Tag301.cCorrectPlayerMovePrediction: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CCorrectPlayerMovePrediction _payload71 = packet.getCCorrectPlayerMovePrediction(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(12); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload71.predictionType)); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload71.pos[0]); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload71.pos[1]); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload71.pos[2]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload71.posDelta[0]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload71.posDelta[1]); + *cast(double*)(_retArea.ptr + 64) = cast(double)(_payload71.posDelta[2]); + *cast(double*)(_retArea.ptr + 72) = cast(double)(_payload71.rotation[0]); + *cast(double*)(_retArea.ptr + 80) = cast(double)(_payload71.rotation[1]); + if (_payload71.vehicleAngularVelocity.isSome) { + ref _payload75 = _payload71.vehicleAngularVelocity.unwrap(); + *cast(ubyte*)(_retArea.ptr + 88) = cast(ubyte)(1); + *cast(float*)(_retArea.ptr + 92) = cast(float)(_payload75); + } else { + *cast(ubyte*)(_retArea.ptr + 88) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + 96) = cast(ubyte)(cast(uint)(_payload71.onGround)); + *cast(ulong*)(_retArea.ptr + 104) = cast(ulong)(cast(ulong)(_payload71.tick)); + break; + } + case _Tag301.cCraftingData: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CCraftingData _payload77 = packet.getCCraftingData(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(13); + auto _listSrc100 = _payload77.recipes; + auto _list100 = _listSrc100.length ? wit.common.malloc(_listSrc100.length * ((48+8*size_t.sizeof))) : null; + assert(!_listSrc100.length || _list100); + if (_listSrc100.length) deallocate ~= _list100; + foreach (_elem78_idx, ref _elem78; _listSrc100) { + auto _base78 = _list100 + _elem78_idx * ((48+8*size_t.sizeof)); + alias _Tag99 = wit.pumpkin.plugin.bedrock_packets.imports.BedrockRecipe.Tag; + final switch (_elem78.tag) { + case _Tag99.shapeless: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.BedrockShapelessRecipe _payload80 = _elem78.getShapeless(); + *cast(ubyte*)(_base78 + 0) = cast(ubyte)(0); + *cast(size_t*)(_base78 + (8+1*size_t.sizeof)) = cast(size_t)(_payload80.recipeId.length); + *cast(void**)(_base78 + 8) = cast(void*)(cast(void*)(_payload80.recipeId.ptr)); + auto _listSrc82 = _payload80.input; + auto _list82 = _listSrc82.length ? wit.common.malloc(_listSrc82.length * ((8+2*size_t.sizeof))) : null; + assert(!_listSrc82.length || _list82); + if (_listSrc82.length) deallocate ~= _list82; + foreach (_elem81_idx, ref _elem81; _listSrc82) { + auto _base81 = _list82 + _elem81_idx * ((8+2*size_t.sizeof)); + *cast(size_t*)(_base81 + size_t.sizeof) = cast(size_t)(_elem81.itemIdentifier.length); + *cast(void**)(_base81 + 0) = cast(void*)(cast(void*)(_elem81.itemIdentifier.ptr)); + *cast(uint*)(_base81 + (2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem81.metadataValue)); + *cast(uint*)(_base81 + (4+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem81.count)); + + } + *cast(size_t*)(_base78 + (8+3*size_t.sizeof)) = cast(size_t)(_payload80.input.length); + *cast(void**)(_base78 + (8+2*size_t.sizeof)) = cast(void*)(_list82); + auto _listSrc88 = _payload80.output; + auto _list88 = _listSrc88.length ? wit.common.malloc(_listSrc88.length * ((24+6*size_t.sizeof))) : null; + assert(!_listSrc88.length || _list88); + if (_listSrc88.length) deallocate ~= _list88; + foreach (_elem83_idx, ref _elem83; _listSrc88) { + auto _base83 = _list88 + _elem83_idx * ((24+6*size_t.sizeof)); + *cast(uint*)(_base83 + 0) = cast(uint)(cast(uint)(_elem83.id)); + *cast(uint*)(_base83 + 4) = cast(uint)(cast(uint)(_elem83.stackSize)); + *cast(uint*)(_base83 + 8) = cast(uint)(cast(uint)(_elem83.auxValue)); + *cast(uint*)(_base83 + 12) = cast(uint)(cast(uint)(_elem83.blockRuntimeId)); + *cast(size_t*)(_base83 + (16+1*size_t.sizeof)) = cast(size_t)(_elem83.nbtData.length); + *cast(void**)(_base83 + 16) = cast(void*)(cast(void*)(_elem83.nbtData.ptr)); + auto _listSrc85 = _elem83.placeOnBlocks; + auto _list85 = _listSrc85.length ? wit.common.malloc(_listSrc85.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc85.length || _list85); + if (_listSrc85.length) deallocate ~= _list85; + foreach (_elem84_idx, ref _elem84; _listSrc85) { + auto _base84 = _list85 + _elem84_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base84 + size_t.sizeof) = cast(size_t)(_elem84.length); + *cast(void**)(_base84 + 0) = cast(void*)(cast(void*)(_elem84.ptr)); + + } + *cast(size_t*)(_base83 + (16+3*size_t.sizeof)) = cast(size_t)(_elem83.placeOnBlocks.length); + *cast(void**)(_base83 + (16+2*size_t.sizeof)) = cast(void*)(_list85); + auto _listSrc87 = _elem83.destroyBlocks; + auto _list87 = _listSrc87.length ? wit.common.malloc(_listSrc87.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc87.length || _list87); + if (_listSrc87.length) deallocate ~= _list87; + foreach (_elem86_idx, ref _elem86; _listSrc87) { + auto _base86 = _list87 + _elem86_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base86 + size_t.sizeof) = cast(size_t)(_elem86.length); + *cast(void**)(_base86 + 0) = cast(void*)(cast(void*)(_elem86.ptr)); + + } + *cast(size_t*)(_base83 + (16+5*size_t.sizeof)) = cast(size_t)(_elem83.destroyBlocks.length); + *cast(void**)(_base83 + (16+4*size_t.sizeof)) = cast(void*)(_list87); + *cast(ulong*)(_base83 + (16+6*size_t.sizeof)) = cast(ulong)(cast(ulong)(_elem83.shieldBlockingTick)); + + } + *cast(size_t*)(_base78 + (8+5*size_t.sizeof)) = cast(size_t)(_payload80.output.length); + *cast(void**)(_base78 + (8+4*size_t.sizeof)) = cast(void*)(_list88); + *cast(ulong*)(_base78 + (8+6*size_t.sizeof)) = cast(ulong)(_payload80.uuid.high); + *cast(ulong*)(_base78 + (16+6*size_t.sizeof)) = cast(ulong)(_payload80.uuid.low); + *cast(size_t*)(_base78 + (24+7*size_t.sizeof)) = cast(size_t)(_payload80.block.length); + *cast(void**)(_base78 + (24+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload80.block.ptr)); + *cast(uint*)(_base78 + (24+8*size_t.sizeof)) = cast(uint)(cast(uint)(_payload80.priority)); + *cast(uint*)(_base78 + (28+8*size_t.sizeof)) = cast(uint)(cast(uint)(_payload80.unlockRequirement.context)); + *cast(uint*)(_base78 + (32+8*size_t.sizeof)) = cast(uint)(cast(uint)(_payload80.recipeNetworkId)); + break; + } + case _Tag99.shaped: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.BedrockShapedRecipe _payload90 = _elem78.getShaped(); + *cast(ubyte*)(_base78 + 0) = cast(ubyte)(1); + *cast(size_t*)(_base78 + (8+1*size_t.sizeof)) = cast(size_t)(_payload90.recipeId.length); + *cast(void**)(_base78 + 8) = cast(void*)(cast(void*)(_payload90.recipeId.ptr)); + *cast(uint*)(_base78 + (8+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload90.width)); + *cast(uint*)(_base78 + (12+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload90.height)); + auto _listSrc92 = _payload90.input; + auto _list92 = _listSrc92.length ? wit.common.malloc(_listSrc92.length * ((8+2*size_t.sizeof))) : null; + assert(!_listSrc92.length || _list92); + if (_listSrc92.length) deallocate ~= _list92; + foreach (_elem91_idx, ref _elem91; _listSrc92) { + auto _base91 = _list92 + _elem91_idx * ((8+2*size_t.sizeof)); + *cast(size_t*)(_base91 + size_t.sizeof) = cast(size_t)(_elem91.itemIdentifier.length); + *cast(void**)(_base91 + 0) = cast(void*)(cast(void*)(_elem91.itemIdentifier.ptr)); + *cast(uint*)(_base91 + (2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem91.metadataValue)); + *cast(uint*)(_base91 + (4+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem91.count)); + + } + *cast(size_t*)(_base78 + (16+3*size_t.sizeof)) = cast(size_t)(_payload90.input.length); + *cast(void**)(_base78 + (16+2*size_t.sizeof)) = cast(void*)(_list92); + auto _listSrc98 = _payload90.output; + auto _list98 = _listSrc98.length ? wit.common.malloc(_listSrc98.length * ((24+6*size_t.sizeof))) : null; + assert(!_listSrc98.length || _list98); + if (_listSrc98.length) deallocate ~= _list98; + foreach (_elem93_idx, ref _elem93; _listSrc98) { + auto _base93 = _list98 + _elem93_idx * ((24+6*size_t.sizeof)); + *cast(uint*)(_base93 + 0) = cast(uint)(cast(uint)(_elem93.id)); + *cast(uint*)(_base93 + 4) = cast(uint)(cast(uint)(_elem93.stackSize)); + *cast(uint*)(_base93 + 8) = cast(uint)(cast(uint)(_elem93.auxValue)); + *cast(uint*)(_base93 + 12) = cast(uint)(cast(uint)(_elem93.blockRuntimeId)); + *cast(size_t*)(_base93 + (16+1*size_t.sizeof)) = cast(size_t)(_elem93.nbtData.length); + *cast(void**)(_base93 + 16) = cast(void*)(cast(void*)(_elem93.nbtData.ptr)); + auto _listSrc95 = _elem93.placeOnBlocks; + auto _list95 = _listSrc95.length ? wit.common.malloc(_listSrc95.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc95.length || _list95); + if (_listSrc95.length) deallocate ~= _list95; + foreach (_elem94_idx, ref _elem94; _listSrc95) { + auto _base94 = _list95 + _elem94_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base94 + size_t.sizeof) = cast(size_t)(_elem94.length); + *cast(void**)(_base94 + 0) = cast(void*)(cast(void*)(_elem94.ptr)); + + } + *cast(size_t*)(_base93 + (16+3*size_t.sizeof)) = cast(size_t)(_elem93.placeOnBlocks.length); + *cast(void**)(_base93 + (16+2*size_t.sizeof)) = cast(void*)(_list95); + auto _listSrc97 = _elem93.destroyBlocks; + auto _list97 = _listSrc97.length ? wit.common.malloc(_listSrc97.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc97.length || _list97); + if (_listSrc97.length) deallocate ~= _list97; + foreach (_elem96_idx, ref _elem96; _listSrc97) { + auto _base96 = _list97 + _elem96_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base96 + size_t.sizeof) = cast(size_t)(_elem96.length); + *cast(void**)(_base96 + 0) = cast(void*)(cast(void*)(_elem96.ptr)); + + } + *cast(size_t*)(_base93 + (16+5*size_t.sizeof)) = cast(size_t)(_elem93.destroyBlocks.length); + *cast(void**)(_base93 + (16+4*size_t.sizeof)) = cast(void*)(_list97); + *cast(ulong*)(_base93 + (16+6*size_t.sizeof)) = cast(ulong)(cast(ulong)(_elem93.shieldBlockingTick)); + + } + *cast(size_t*)(_base78 + (16+5*size_t.sizeof)) = cast(size_t)(_payload90.output.length); + *cast(void**)(_base78 + (16+4*size_t.sizeof)) = cast(void*)(_list98); + *cast(ulong*)(_base78 + (16+6*size_t.sizeof)) = cast(ulong)(_payload90.uuid.high); + *cast(ulong*)(_base78 + (24+6*size_t.sizeof)) = cast(ulong)(_payload90.uuid.low); + *cast(size_t*)(_base78 + (32+7*size_t.sizeof)) = cast(size_t)(_payload90.block.length); + *cast(void**)(_base78 + (32+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload90.block.ptr)); + *cast(uint*)(_base78 + (32+8*size_t.sizeof)) = cast(uint)(cast(uint)(_payload90.priority)); + *cast(ubyte*)(_base78 + (36+8*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload90.assumeSymmetry)); + *cast(uint*)(_base78 + (40+8*size_t.sizeof)) = cast(uint)(cast(uint)(_payload90.unlockRequirement.context)); + *cast(uint*)(_base78 + (44+8*size_t.sizeof)) = cast(uint)(cast(uint)(_payload90.recipeNetworkId)); + break; + } + } + + } + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload77.recipes.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(_list100); + *cast(ubyte*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload77.cleanRecipes)); + break; + } + case _Tag301.cCreativeContent: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CCreativeContent _payload102 = packet.getCCreativeContent(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(14); + auto _listSrc108 = _payload102.groups; + auto _list108 = _listSrc108.length ? wit.common.malloc(_listSrc108.length * ((32+8*size_t.sizeof))) : null; + assert(!_listSrc108.length || _list108); + if (_listSrc108.length) deallocate ~= _list108; + foreach (_elem103_idx, ref _elem103; _listSrc108) { + auto _base103 = _list108 + _elem103_idx * ((32+8*size_t.sizeof)); + *cast(ubyte*)(_base103 + 0) = cast(ubyte)(cast(uint)(_elem103.creativeCategory)); + *cast(size_t*)(_base103 + (2*size_t.sizeof)) = cast(size_t)(_elem103.name.length); + *cast(void**)(_base103 + size_t.sizeof) = cast(void*)(cast(void*)(_elem103.name.ptr)); + *cast(uint*)(_base103 + (8+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem103.groupIconItem.id)); + *cast(uint*)(_base103 + (12+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem103.groupIconItem.stackSize)); + *cast(uint*)(_base103 + (16+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem103.groupIconItem.auxValue)); + *cast(uint*)(_base103 + (20+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem103.groupIconItem.blockRuntimeId)); + *cast(size_t*)(_base103 + (24+3*size_t.sizeof)) = cast(size_t)(_elem103.groupIconItem.nbtData.length); + *cast(void**)(_base103 + (24+2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem103.groupIconItem.nbtData.ptr)); + auto _listSrc105 = _elem103.groupIconItem.placeOnBlocks; + auto _list105 = _listSrc105.length ? wit.common.malloc(_listSrc105.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc105.length || _list105); + if (_listSrc105.length) deallocate ~= _list105; + foreach (_elem104_idx, ref _elem104; _listSrc105) { + auto _base104 = _list105 + _elem104_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base104 + size_t.sizeof) = cast(size_t)(_elem104.length); + *cast(void**)(_base104 + 0) = cast(void*)(cast(void*)(_elem104.ptr)); + + } + *cast(size_t*)(_base103 + (24+5*size_t.sizeof)) = cast(size_t)(_elem103.groupIconItem.placeOnBlocks.length); + *cast(void**)(_base103 + (24+4*size_t.sizeof)) = cast(void*)(_list105); + auto _listSrc107 = _elem103.groupIconItem.destroyBlocks; + auto _list107 = _listSrc107.length ? wit.common.malloc(_listSrc107.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc107.length || _list107); + if (_listSrc107.length) deallocate ~= _list107; + foreach (_elem106_idx, ref _elem106; _listSrc107) { + auto _base106 = _list107 + _elem106_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base106 + size_t.sizeof) = cast(size_t)(_elem106.length); + *cast(void**)(_base106 + 0) = cast(void*)(cast(void*)(_elem106.ptr)); + + } + *cast(size_t*)(_base103 + (24+7*size_t.sizeof)) = cast(size_t)(_elem103.groupIconItem.destroyBlocks.length); + *cast(void**)(_base103 + (24+6*size_t.sizeof)) = cast(void*)(_list107); + *cast(ulong*)(_base103 + (24+8*size_t.sizeof)) = cast(ulong)(cast(ulong)(_elem103.groupIconItem.shieldBlockingTick)); + + } + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload102.groups.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(_list108); + auto _listSrc114 = _payload102.entries; + auto _list114 = _listSrc114.length ? wit.common.malloc(_listSrc114.length * ((40+6*size_t.sizeof))) : null; + assert(!_listSrc114.length || _list114); + if (_listSrc114.length) deallocate ~= _list114; + foreach (_elem109_idx, ref _elem109; _listSrc114) { + auto _base109 = _list114 + _elem109_idx * ((40+6*size_t.sizeof)); + *cast(uint*)(_base109 + 0) = cast(uint)(cast(uint)(_elem109.id)); + *cast(uint*)(_base109 + 8) = cast(uint)(cast(uint)(_elem109.item.id)); + *cast(uint*)(_base109 + 12) = cast(uint)(cast(uint)(_elem109.item.stackSize)); + *cast(uint*)(_base109 + 16) = cast(uint)(cast(uint)(_elem109.item.auxValue)); + *cast(uint*)(_base109 + 20) = cast(uint)(cast(uint)(_elem109.item.blockRuntimeId)); + *cast(size_t*)(_base109 + (24+1*size_t.sizeof)) = cast(size_t)(_elem109.item.nbtData.length); + *cast(void**)(_base109 + 24) = cast(void*)(cast(void*)(_elem109.item.nbtData.ptr)); + auto _listSrc111 = _elem109.item.placeOnBlocks; + auto _list111 = _listSrc111.length ? wit.common.malloc(_listSrc111.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc111.length || _list111); + if (_listSrc111.length) deallocate ~= _list111; + foreach (_elem110_idx, ref _elem110; _listSrc111) { + auto _base110 = _list111 + _elem110_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base110 + size_t.sizeof) = cast(size_t)(_elem110.length); + *cast(void**)(_base110 + 0) = cast(void*)(cast(void*)(_elem110.ptr)); + + } + *cast(size_t*)(_base109 + (24+3*size_t.sizeof)) = cast(size_t)(_elem109.item.placeOnBlocks.length); + *cast(void**)(_base109 + (24+2*size_t.sizeof)) = cast(void*)(_list111); + auto _listSrc113 = _elem109.item.destroyBlocks; + auto _list113 = _listSrc113.length ? wit.common.malloc(_listSrc113.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc113.length || _list113); + if (_listSrc113.length) deallocate ~= _list113; + foreach (_elem112_idx, ref _elem112; _listSrc113) { + auto _base112 = _list113 + _elem112_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base112 + size_t.sizeof) = cast(size_t)(_elem112.length); + *cast(void**)(_base112 + 0) = cast(void*)(cast(void*)(_elem112.ptr)); + + } + *cast(size_t*)(_base109 + (24+5*size_t.sizeof)) = cast(size_t)(_elem109.item.destroyBlocks.length); + *cast(void**)(_base109 + (24+4*size_t.sizeof)) = cast(void*)(_list113); + *cast(ulong*)(_base109 + (24+6*size_t.sizeof)) = cast(ulong)(cast(ulong)(_elem109.item.shieldBlockingTick)); + *cast(uint*)(_base109 + (32+6*size_t.sizeof)) = cast(uint)(cast(uint)(_elem109.groupIndex)); + + } + *cast(size_t*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(size_t)(_payload102.entries.length); + *cast(void**)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(void*)(_list114); + break; + } + case _Tag301.cDisconnect: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CDisconnect _payload116 = packet.getCDisconnect(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(15); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload116.reason)); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload116.skipMessage)); + *cast(size_t*)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(size_t)(_payload116.message.length); + *cast(void**)(_retArea.ptr + 24) = cast(void*)(cast(void*)(_payload116.message.ptr)); + *cast(size_t*)(_retArea.ptr + (24+3*size_t.sizeof)) = cast(size_t)(_payload116.filteredMessage.length); + *cast(void**)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload116.filteredMessage.ptr)); + break; + } + case _Tag301.cGamerulesChanged: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CGamerulesChanged _payload118 = packet.getCGamerulesChanged(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(16); + auto _listSrc120 = _payload118.ruleData; + auto _list120 = _listSrc120.length ? wit.common.malloc(_listSrc120.length * ((3*size_t.sizeof))) : null; + assert(!_listSrc120.length || _list120); + if (_listSrc120.length) deallocate ~= _list120; + foreach (_elem119_idx, ref _elem119; _listSrc120) { + auto _base119 = _list120 + _elem119_idx * ((3*size_t.sizeof)); + *cast(size_t*)(_base119 + size_t.sizeof) = cast(size_t)(_elem119.ruleName.length); + *cast(void**)(_base119 + 0) = cast(void*)(cast(void*)(_elem119.ruleName.ptr)); + *cast(ubyte*)(_base119 + (2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem119.ruleCanBeModified)); + *cast(ubyte*)(_base119 + (1+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem119.ruleValue)); + + } + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload118.ruleData.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(_list120); + break; + } + case _Tag301.cInventoryContent: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CInventoryContent _payload122 = packet.getCInventoryContent(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(17); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload122.containerId)); + auto _listSrc128 = _payload122.slots; + auto _list128 = _listSrc128.length ? wit.common.malloc(_listSrc128.length * ((24+2*size_t.sizeof))) : null; + assert(!_listSrc128.length || _list128); + if (_listSrc128.length) deallocate ~= _list128; + foreach (_elem123_idx, ref _elem123; _listSrc128) { + auto _base123 = _list128 + _elem123_idx * ((24+2*size_t.sizeof)); + *cast(uint*)(_base123 + 0) = cast(uint)(cast(uint)(_elem123.id)); + *cast(uint*)(_base123 + 4) = cast(uint)(cast(uint)(_elem123.stackSize)); + *cast(uint*)(_base123 + 8) = cast(uint)(cast(uint)(_elem123.auxValue)); + *cast(uint*)(_base123 + 12) = cast(uint)(cast(uint)(_elem123.blockRuntimeId)); + *cast(size_t*)(_base123 + (16+1*size_t.sizeof)) = cast(size_t)(_elem123.extraData.length); + *cast(void**)(_base123 + 16) = cast(void*)(cast(void*)(_elem123.extraData.ptr)); + if (_elem123.netId.isSome) { + ref _payload127 = _elem123.netId.unwrap(); + *cast(ubyte*)(_base123 + (16+2*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base123 + (20+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload127)); + } else { + *cast(ubyte*)(_base123 + (16+2*size_t.sizeof)) = cast(ubyte)(0); + } + + } + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload122.slots.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(_list128); + *cast(ubyte*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload122.fullContainerName.containerName)); + if (_payload122.fullContainerName.dynamicId.isSome) { + ref _payload132 = _payload122.fullContainerName.dynamicId.unwrap(); + *cast(ubyte*)(_retArea.ptr + (20+3*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (24+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload132)); + } else { + *cast(ubyte*)(_retArea.ptr + (20+3*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(uint*)(_retArea.ptr + (24+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload122.storageItem.id)); + *cast(uint*)(_retArea.ptr + (28+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload122.storageItem.stackSize)); + *cast(uint*)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload122.storageItem.auxValue)); + *cast(uint*)(_retArea.ptr + (36+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload122.storageItem.blockRuntimeId)); + *cast(size_t*)(_retArea.ptr + (40+5*size_t.sizeof)) = cast(size_t)(_payload122.storageItem.extraData.length); + *cast(void**)(_retArea.ptr + (40+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload122.storageItem.extraData.ptr)); + if (_payload122.storageItem.netId.isSome) { + ref _payload136 = _payload122.storageItem.netId.unwrap(); + *cast(ubyte*)(_retArea.ptr + (40+6*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (44+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload136)); + } else { + *cast(ubyte*)(_retArea.ptr + (40+6*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag301.cInventorySlot: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CInventorySlot _payload138 = packet.getCInventorySlot(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(18); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload138.containerId)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload138.slot)); + if (_payload138.fullContainerName.isSome) { + ref _payload142 = _payload138.fullContainerName.unwrap(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(1); + *cast(ubyte*)(_retArea.ptr + 28) = cast(ubyte)(cast(uint)(_payload142.containerName)); + if (_payload142.dynamicId.isSome) { + ref _payload146 = _payload142.dynamicId.unwrap(); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload146)); + } else { + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(0); + } + } else { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(0); + } + if (_payload138.storageItem.isSome) { + ref _payload150 = _payload138.storageItem.unwrap(); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload150.id)); + *cast(uint*)(_retArea.ptr + (44+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload150.stackSize)); + *cast(uint*)(_retArea.ptr + (48+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload150.auxValue)); + *cast(uint*)(_retArea.ptr + (52+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload150.blockRuntimeId)); + *cast(size_t*)(_retArea.ptr + (56+2*size_t.sizeof)) = cast(size_t)(_payload150.extraData.length); + *cast(void**)(_retArea.ptr + (56+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload150.extraData.ptr)); + if (_payload150.netId.isSome) { + ref _payload154 = _payload150.netId.unwrap(); + *cast(ubyte*)(_retArea.ptr + (56+3*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (60+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload154)); + } else { + *cast(ubyte*)(_retArea.ptr + (56+3*size_t.sizeof)) = cast(ubyte)(0); + } + } else { + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(0); + } + *cast(uint*)(_retArea.ptr + (64+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload138.item.id)); + *cast(uint*)(_retArea.ptr + (68+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload138.item.stackSize)); + *cast(uint*)(_retArea.ptr + (72+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload138.item.auxValue)); + *cast(uint*)(_retArea.ptr + (76+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload138.item.blockRuntimeId)); + *cast(size_t*)(_retArea.ptr + (80+4*size_t.sizeof)) = cast(size_t)(_payload138.item.extraData.length); + *cast(void**)(_retArea.ptr + (80+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload138.item.extraData.ptr)); + if (_payload138.item.netId.isSome) { + ref _payload158 = _payload138.item.netId.unwrap(); + *cast(ubyte*)(_retArea.ptr + (80+5*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (84+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload158)); + } else { + *cast(ubyte*)(_retArea.ptr + (80+5*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag301.cItemRegistry: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CItemRegistry _payload160 = packet.getCItemRegistry(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(19); + auto _listSrc162 = _payload160.items; + auto _list162 = _listSrc162.length ? wit.common.malloc(_listSrc162.length * ((8+5*size_t.sizeof))) : null; + assert(!_listSrc162.length || _list162); + if (_listSrc162.length) deallocate ~= _list162; + foreach (_elem161_idx, ref _elem161; _listSrc162) { + auto _base161 = _list162 + _elem161_idx * ((8+5*size_t.sizeof)); + *cast(size_t*)(_base161 + size_t.sizeof) = cast(size_t)(_elem161.itemName.length); + *cast(void**)(_base161 + 0) = cast(void*)(cast(void*)(_elem161.itemName.ptr)); + *cast(uint*)(_base161 + (2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem161.itemId)); + *cast(ubyte*)(_base161 + (4+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem161.isComponentBased)); + *cast(uint*)(_base161 + (8+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem161.itemVersion)); + *cast(size_t*)(_base161 + (8+4*size_t.sizeof)) = cast(size_t)(_elem161.componentData.length); + *cast(void**)(_base161 + (8+3*size_t.sizeof)) = cast(void*)(cast(void*)(_elem161.componentData.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload160.items.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(_list162); + break; + } + case _Tag301.cItemStackResponse: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CItemStackResponse _payload164 = packet.getCItemStackResponse(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(20); + auto _listSrc174 = _payload164.responses; + auto _list174 = _listSrc174.length ? wit.common.malloc(_listSrc174.length * ((8+2*size_t.sizeof))) : null; + assert(!_listSrc174.length || _list174); + if (_listSrc174.length) deallocate ~= _list174; + foreach (_elem165_idx, ref _elem165; _listSrc174) { + auto _base165 = _list174 + _elem165_idx * ((8+2*size_t.sizeof)); + *cast(ubyte*)(_base165 + 0) = cast(ubyte)(cast(uint)(_elem165.result)); + *cast(uint*)(_base165 + 4) = cast(uint)(cast(uint)(_elem165.clientRequestId)); + auto _listSrc173 = _elem165.containers; + auto _list173 = _listSrc173.length ? wit.common.malloc(_listSrc173.length * ((8+3*size_t.sizeof))) : null; + assert(!_listSrc173.length || _list173); + if (_listSrc173.length) deallocate ~= _list173; + foreach (_elem166_idx, ref _elem166; _listSrc173) { + auto _base166 = _list173 + _elem166_idx * ((8+3*size_t.sizeof)); + *cast(ubyte*)(_base166 + 0) = cast(ubyte)(cast(uint)(_elem166.fullContainerName.containerName)); + if (_elem166.fullContainerName.dynamicId.isSome) { + ref _payload170 = _elem166.fullContainerName.dynamicId.unwrap(); + *cast(ubyte*)(_base166 + 4) = cast(ubyte)(1); + *cast(uint*)(_base166 + 8) = cast(uint)(cast(uint)(_payload170)); + } else { + *cast(ubyte*)(_base166 + 4) = cast(ubyte)(0); + } + auto _listSrc172 = _elem166.slots; + auto _list172 = _listSrc172.length ? wit.common.malloc(_listSrc172.length * ((8+5*size_t.sizeof))) : null; + assert(!_listSrc172.length || _list172); + if (_listSrc172.length) deallocate ~= _list172; + foreach (_elem171_idx, ref _elem171; _listSrc172) { + auto _base171 = _list172 + _elem171_idx * ((8+5*size_t.sizeof)); + *cast(ubyte*)(_base171 + 0) = cast(ubyte)(cast(uint)(_elem171.requestedSlot)); + *cast(ubyte*)(_base171 + 1) = cast(ubyte)(cast(uint)(_elem171.slot)); + *cast(ubyte*)(_base171 + 2) = cast(ubyte)(cast(uint)(_elem171.amount)); + *cast(uint*)(_base171 + 4) = cast(uint)(cast(uint)(_elem171.itemStackNetId)); + *cast(size_t*)(_base171 + (8+1*size_t.sizeof)) = cast(size_t)(_elem171.customName.length); + *cast(void**)(_base171 + 8) = cast(void*)(cast(void*)(_elem171.customName.ptr)); + *cast(size_t*)(_base171 + (8+3*size_t.sizeof)) = cast(size_t)(_elem171.filteredCustomName.length); + *cast(void**)(_base171 + (8+2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem171.filteredCustomName.ptr)); + *cast(uint*)(_base171 + (8+4*size_t.sizeof)) = cast(uint)(cast(uint)(_elem171.durabilityCorrection)); + + } + *cast(size_t*)(_base166 + (8+2*size_t.sizeof)) = cast(size_t)(_elem166.slots.length); + *cast(void**)(_base166 + (8+1*size_t.sizeof)) = cast(void*)(_list172); + + } + *cast(size_t*)(_base165 + (8+1*size_t.sizeof)) = cast(size_t)(_elem165.containers.length); + *cast(void**)(_base165 + 8) = cast(void*)(_list173); + + } + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload164.responses.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(_list174); + break; + } + case _Tag301.cLevelChunk: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CLevelChunk _payload176 = packet.getCLevelChunk(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(21); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload176.dimension)); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload176.cacheEnabled)); + *cast(size_t*)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(size_t)(_payload176.chunk.length); + *cast(void**)(_retArea.ptr + 24) = cast(void*)(cast(void*)(_payload176.chunk.ptr)); + auto _listSrc178 = _payload176.blockActors; + auto _list178 = _listSrc178.length ? wit.common.malloc(_listSrc178.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc178.length || _list178); + if (_listSrc178.length) deallocate ~= _list178; + foreach (_elem177_idx, ref _elem177; _listSrc178) { + auto _base177 = _list178 + _elem177_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base177 + size_t.sizeof) = cast(size_t)(_elem177.length); + *cast(void**)(_base177 + 0) = cast(void*)(cast(void*)(_elem177.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (24+3*size_t.sizeof)) = cast(size_t)(_payload176.blockActors.length); + *cast(void**)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(void*)(_list178); + break; + } + case _Tag301.cLevelEvent: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CLevelEvent _payload180 = packet.getCLevelEvent(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(22); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload180.eventId)); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload180.position[0]); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload180.position[1]); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload180.position[2]); + *cast(uint*)(_retArea.ptr + 48) = cast(uint)(cast(uint)(_payload180.data)); + break; + } + case _Tag301.cLevelSoundEvent: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CLevelSoundEvent _payload182 = packet.getCLevelSoundEvent(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(23); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload182.soundEvent.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload182.soundEvent.ptr)); + *cast(double*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(double)(_payload182.position[0]); + *cast(double*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(double)(_payload182.position[1]); + *cast(double*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(double)(_payload182.position[2]); + *cast(uint*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload182.data)); + *cast(size_t*)(_retArea.ptr + (40+4*size_t.sizeof)) = cast(size_t)(_payload182.actorIdentifier.length); + *cast(void**)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload182.actorIdentifier.ptr)); + *cast(ubyte*)(_retArea.ptr + (40+5*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload182.isBaby)); + *cast(ubyte*)(_retArea.ptr + (41+5*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload182.isGlobal)); + *cast(ulong*)(_retArea.ptr + (40+6*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload182.actorUniqueId)); + if (_payload182.fireAtPosition.isSome) { + ref _payload186 = _payload182.fireAtPosition.unwrap(); + *cast(ubyte*)(_retArea.ptr + (48+6*size_t.sizeof)) = cast(ubyte)(1); + *cast(double*)(_retArea.ptr + (56+6*size_t.sizeof)) = cast(double)(_payload186[0]); + *cast(double*)(_retArea.ptr + (64+6*size_t.sizeof)) = cast(double)(_payload186[1]); + *cast(double*)(_retArea.ptr + (72+6*size_t.sizeof)) = cast(double)(_payload186[2]); + } else { + *cast(ubyte*)(_retArea.ptr + (48+6*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag301.cMobEffect: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CMobEffect _payload188 = packet.getCMobEffect(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(24); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(cast(ulong)(_payload188.targetRuntimeId)); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload188.eventId)); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload188.effectId)); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload188.effectAmplifier)); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(cast(uint)(_payload188.showParticles)); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload188.effectDurationTicks)); + *cast(ulong*)(_retArea.ptr + 48) = cast(ulong)(cast(ulong)(_payload188.tick)); + *cast(ubyte*)(_retArea.ptr + 56) = cast(ubyte)(cast(uint)(_payload188.ambient)); + break; + } + case _Tag301.cMobEquipment: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CMobEquipment _payload190 = packet.getCMobEquipment(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(25); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(cast(ulong)(_payload190.targetRuntimeId)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload190.item.id)); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload190.item.stackSize)); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload190.item.auxValue)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload190.item.blockRuntimeId)); + *cast(size_t*)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(size_t)(_payload190.item.extraData.length); + *cast(void**)(_retArea.ptr + 40) = cast(void*)(cast(void*)(_payload190.item.extraData.ptr)); + if (_payload190.item.netId.isSome) { + ref _payload194 = _payload190.item.netId.unwrap(); + *cast(ubyte*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (44+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload194)); + } else { + *cast(ubyte*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload190.slot)); + *cast(ubyte*)(_retArea.ptr + (49+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload190.selectedSlot)); + *cast(ubyte*)(_retArea.ptr + (50+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload190.containerId)); + break; + } + case _Tag301.cModalFormRequest: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CModalFormRequest _payload196 = packet.getCModalFormRequest(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(26); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload196.formId)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload196.formUiJson.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload196.formUiJson.ptr)); + break; + } + case _Tag301.cMoveActorAbsolute: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CMoveActorAbsolute _payload198 = packet.getCMoveActorAbsolute(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(27); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(cast(ulong)(_payload198.actorRuntimeId)); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload198.header)); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload198.position[0]); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload198.position[1]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload198.position[2]); + *cast(ubyte*)(_retArea.ptr + 56) = cast(ubyte)(cast(uint)(_payload198.rotationX)); + *cast(ubyte*)(_retArea.ptr + 57) = cast(ubyte)(cast(uint)(_payload198.rotationY)); + *cast(ubyte*)(_retArea.ptr + 58) = cast(ubyte)(cast(uint)(_payload198.rotationYHead)); + break; + } + case _Tag301.cMoveActorDelta: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CMoveActorDelta _payload200 = packet.getCMoveActorDelta(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(28); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(cast(ulong)(_payload200.entityRuntimeId)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload200.flags)); + *cast(float*)(_retArea.ptr + 28) = cast(float)(_payload200.x); + *cast(float*)(_retArea.ptr + 32) = cast(float)(_payload200.y); + *cast(float*)(_retArea.ptr + 36) = cast(float)(_payload200.z); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(cast(uint)(_payload200.pitch)); + *cast(ubyte*)(_retArea.ptr + 41) = cast(ubyte)(cast(uint)(_payload200.yaw)); + *cast(ubyte*)(_retArea.ptr + 42) = cast(ubyte)(cast(uint)(_payload200.headYaw)); + break; + } + case _Tag301.cMovePlayer: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CMovePlayer _payload202 = packet.getCMovePlayer(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(29); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(cast(ulong)(_payload202.playerRuntimeId)); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload202.position[0]); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload202.position[1]); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload202.position[2]); + *cast(float*)(_retArea.ptr + 48) = cast(float)(_payload202.pitch); + *cast(float*)(_retArea.ptr + 52) = cast(float)(_payload202.yaw); + *cast(float*)(_retArea.ptr + 56) = cast(float)(_payload202.headYaw); + *cast(ubyte*)(_retArea.ptr + 60) = cast(ubyte)(cast(uint)(_payload202.mode)); + *cast(ubyte*)(_retArea.ptr + 61) = cast(ubyte)(cast(uint)(_payload202.onGround)); + *cast(ulong*)(_retArea.ptr + 64) = cast(ulong)(cast(ulong)(_payload202.ridingRuntimeId)); + *cast(uint*)(_retArea.ptr + 72) = cast(uint)(cast(uint)(_payload202.teleportCause)); + *cast(uint*)(_retArea.ptr + 76) = cast(uint)(cast(uint)(_payload202.teleportSourceEntityType)); + *cast(ulong*)(_retArea.ptr + 80) = cast(ulong)(cast(ulong)(_payload202.tick)); + break; + } + case _Tag301.cNetworkChunkPublisherUpdate: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CNetworkChunkPublisherUpdate _payload204 = packet.getCNetworkChunkPublisherUpdate(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(30); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload204.posForView[0])); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload204.posForView[1])); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload204.posForView[2])); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload204.newRadius)); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload204.serverBuildChunkList.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload204.serverBuildChunkList.ptr)); + break; + } + case _Tag301.cNetworkSettings: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CNetworkSettings _payload206 = packet.getCNetworkSettings(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(31); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload206.compressionThreshold)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload206.compressionAlgorithm)); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload206.clientThrottleEnabled)); + *cast(ubyte*)(_retArea.ptr + 25) = cast(ubyte)(cast(uint)(_payload206.clientThrottleThreshold)); + *cast(float*)(_retArea.ptr + 28) = cast(float)(_payload206.clientThrottleScalar); + break; + } + case _Tag301.cPlayStatus: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CPlayStatus _payload208 = packet.getCPlayStatus(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(32); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload208)); + break; + } + case _Tag301.cPlayerHotbar: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CPlayerHotbar _payload210 = packet.getCPlayerHotbar(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(33); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload210.selectedSlot)); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload210.containerId)); + *cast(ubyte*)(_retArea.ptr + 21) = cast(ubyte)(cast(uint)(_payload210.shouldSelectSlot)); + break; + } + case _Tag301.cPlayerList: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CPlayerList _payload212 = packet.getCPlayerList(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(34); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload212.action)); + auto _listSrc220 = _payload212.entries; + auto _list220 = _listSrc220.length ? wit.common.malloc(_listSrc220.length * ((48+42*size_t.sizeof))) : null; + assert(!_listSrc220.length || _list220); + if (_listSrc220.length) deallocate ~= _list220; + foreach (_elem213_idx, ref _elem213; _listSrc220) { + auto _base213 = _list220 + _elem213_idx * ((48+42*size_t.sizeof)); + *cast(ulong*)(_base213 + 0) = cast(ulong)(_elem213.uuid.high); + *cast(ulong*)(_base213 + 8) = cast(ulong)(_elem213.uuid.low); + *cast(ulong*)(_base213 + 16) = cast(ulong)(cast(ulong)(_elem213.entityUniqueId)); + *cast(size_t*)(_base213 + (24+1*size_t.sizeof)) = cast(size_t)(_elem213.username.length); + *cast(void**)(_base213 + 24) = cast(void*)(cast(void*)(_elem213.username.ptr)); + *cast(size_t*)(_base213 + (24+3*size_t.sizeof)) = cast(size_t)(_elem213.xuid.length); + *cast(void**)(_base213 + (24+2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem213.xuid.ptr)); + *cast(size_t*)(_base213 + (24+5*size_t.sizeof)) = cast(size_t)(_elem213.platformChatId.length); + *cast(void**)(_base213 + (24+4*size_t.sizeof)) = cast(void*)(cast(void*)(_elem213.platformChatId.ptr)); + *cast(ubyte*)(_base213 + (24+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem213.buildPlatform)); + *cast(size_t*)(_base213 + (24+8*size_t.sizeof)) = cast(size_t)(_elem213.skin.skinId.length); + *cast(void**)(_base213 + (24+7*size_t.sizeof)) = cast(void*)(cast(void*)(_elem213.skin.skinId.ptr)); + *cast(size_t*)(_base213 + (24+10*size_t.sizeof)) = cast(size_t)(_elem213.skin.playFabId.length); + *cast(void**)(_base213 + (24+9*size_t.sizeof)) = cast(void*)(cast(void*)(_elem213.skin.playFabId.ptr)); + *cast(size_t*)(_base213 + (24+12*size_t.sizeof)) = cast(size_t)(_elem213.skin.resourcePatch.length); + *cast(void**)(_base213 + (24+11*size_t.sizeof)) = cast(void*)(cast(void*)(_elem213.skin.resourcePatch.ptr)); + *cast(uint*)(_base213 + (24+13*size_t.sizeof)) = cast(uint)(cast(uint)(_elem213.skin.imageWidth)); + *cast(uint*)(_base213 + (28+13*size_t.sizeof)) = cast(uint)(cast(uint)(_elem213.skin.imageHeight)); + *cast(size_t*)(_base213 + (32+14*size_t.sizeof)) = cast(size_t)(_elem213.skin.skinData.length); + *cast(void**)(_base213 + (32+13*size_t.sizeof)) = cast(void*)(cast(void*)(_elem213.skin.skinData.ptr)); + auto _listSrc215 = _elem213.skin.animations; + auto _list215 = _listSrc215.length ? wit.common.malloc(_listSrc215.length * ((24+2*size_t.sizeof))) : null; + assert(!_listSrc215.length || _list215); + if (_listSrc215.length) deallocate ~= _list215; + foreach (_elem214_idx, ref _elem214; _listSrc215) { + auto _base214 = _list215 + _elem214_idx * ((24+2*size_t.sizeof)); + *cast(double*)(_base214 + 0) = cast(double)(_elem214.frames); + *cast(size_t*)(_base214 + (8+1*size_t.sizeof)) = cast(size_t)(_elem214.image.length); + *cast(void**)(_base214 + 8) = cast(void*)(cast(void*)(_elem214.image.ptr)); + *cast(uint*)(_base214 + (8+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem214.imageHeight)); + *cast(uint*)(_base214 + (12+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem214.imageWidth)); + *cast(uint*)(_base214 + (16+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem214.animationType)); + *cast(uint*)(_base214 + (20+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem214.animationExpression)); + + } + *cast(size_t*)(_base213 + (32+16*size_t.sizeof)) = cast(size_t)(_elem213.skin.animations.length); + *cast(void**)(_base213 + (32+15*size_t.sizeof)) = cast(void*)(_list215); + *cast(uint*)(_base213 + (32+17*size_t.sizeof)) = cast(uint)(cast(uint)(_elem213.skin.capeWidth)); + *cast(uint*)(_base213 + (36+17*size_t.sizeof)) = cast(uint)(cast(uint)(_elem213.skin.capeHeight)); + *cast(size_t*)(_base213 + (40+18*size_t.sizeof)) = cast(size_t)(_elem213.skin.capeData.length); + *cast(void**)(_base213 + (40+17*size_t.sizeof)) = cast(void*)(cast(void*)(_elem213.skin.capeData.ptr)); + *cast(size_t*)(_base213 + (40+20*size_t.sizeof)) = cast(size_t)(_elem213.skin.geometryData.length); + *cast(void**)(_base213 + (40+19*size_t.sizeof)) = cast(void*)(cast(void*)(_elem213.skin.geometryData.ptr)); + *cast(size_t*)(_base213 + (40+22*size_t.sizeof)) = cast(size_t)(_elem213.skin.animationData.length); + *cast(void**)(_base213 + (40+21*size_t.sizeof)) = cast(void*)(cast(void*)(_elem213.skin.animationData.ptr)); + *cast(size_t*)(_base213 + (40+24*size_t.sizeof)) = cast(size_t)(_elem213.skin.geometryDataEngineVersion.length); + *cast(void**)(_base213 + (40+23*size_t.sizeof)) = cast(void*)(cast(void*)(_elem213.skin.geometryDataEngineVersion.ptr)); + *cast(size_t*)(_base213 + (40+26*size_t.sizeof)) = cast(size_t)(_elem213.skin.capeId.length); + *cast(void**)(_base213 + (40+25*size_t.sizeof)) = cast(void*)(cast(void*)(_elem213.skin.capeId.ptr)); + *cast(size_t*)(_base213 + (40+28*size_t.sizeof)) = cast(size_t)(_elem213.skin.fullId.length); + *cast(void**)(_base213 + (40+27*size_t.sizeof)) = cast(void*)(cast(void*)(_elem213.skin.fullId.ptr)); + *cast(size_t*)(_base213 + (40+30*size_t.sizeof)) = cast(size_t)(_elem213.skin.armSize.length); + *cast(void**)(_base213 + (40+29*size_t.sizeof)) = cast(void*)(cast(void*)(_elem213.skin.armSize.ptr)); + *cast(size_t*)(_base213 + (40+32*size_t.sizeof)) = cast(size_t)(_elem213.skin.skinColor.length); + *cast(void**)(_base213 + (40+31*size_t.sizeof)) = cast(void*)(cast(void*)(_elem213.skin.skinColor.ptr)); + auto _listSrc217 = _elem213.skin.personaPieces; + auto _list217 = _listSrc217.length ? wit.common.malloc(_listSrc217.length * ((9*size_t.sizeof))) : null; + assert(!_listSrc217.length || _list217); + if (_listSrc217.length) deallocate ~= _list217; + foreach (_elem216_idx, ref _elem216; _listSrc217) { + auto _base216 = _list217 + _elem216_idx * ((9*size_t.sizeof)); + *cast(ubyte*)(_base216 + 0) = cast(ubyte)(cast(uint)(_elem216.isDefault)); + *cast(size_t*)(_base216 + (2*size_t.sizeof)) = cast(size_t)(_elem216.packId.length); + *cast(void**)(_base216 + size_t.sizeof) = cast(void*)(cast(void*)(_elem216.packId.ptr)); + *cast(size_t*)(_base216 + (4*size_t.sizeof)) = cast(size_t)(_elem216.pieceId.length); + *cast(void**)(_base216 + (3*size_t.sizeof)) = cast(void*)(cast(void*)(_elem216.pieceId.ptr)); + *cast(size_t*)(_base216 + (6*size_t.sizeof)) = cast(size_t)(_elem216.pieceType.length); + *cast(void**)(_base216 + (5*size_t.sizeof)) = cast(void*)(cast(void*)(_elem216.pieceType.ptr)); + *cast(size_t*)(_base216 + (8*size_t.sizeof)) = cast(size_t)(_elem216.productId.length); + *cast(void**)(_base216 + (7*size_t.sizeof)) = cast(void*)(cast(void*)(_elem216.productId.ptr)); + + } + *cast(size_t*)(_base213 + (40+34*size_t.sizeof)) = cast(size_t)(_elem213.skin.personaPieces.length); + *cast(void**)(_base213 + (40+33*size_t.sizeof)) = cast(void*)(_list217); + auto _listSrc219 = _elem213.skin.pieceTintColors; + auto _list219 = _listSrc219.length ? wit.common.malloc(_listSrc219.length * ((4*size_t.sizeof))) : null; + assert(!_listSrc219.length || _list219); + if (_listSrc219.length) deallocate ~= _list219; + foreach (_elem218_idx, ref _elem218; _listSrc219) { + auto _base218 = _list219 + _elem218_idx * ((4*size_t.sizeof)); + *cast(size_t*)(_base218 + size_t.sizeof) = cast(size_t)(_elem218.pieceType.length); + *cast(void**)(_base218 + 0) = cast(void*)(cast(void*)(_elem218.pieceType.ptr)); + *cast(size_t*)(_base218 + (3*size_t.sizeof)) = cast(size_t)(_elem218.colors.length); + *cast(void**)(_base218 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem218.colors.ptr)); + + } + *cast(size_t*)(_base213 + (40+36*size_t.sizeof)) = cast(size_t)(_elem213.skin.pieceTintColors.length); + *cast(void**)(_base213 + (40+35*size_t.sizeof)) = cast(void*)(_list219); + *cast(ubyte*)(_base213 + (40+37*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem213.skin.isPremium)); + *cast(ubyte*)(_base213 + (41+37*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem213.skin.isPersona)); + *cast(ubyte*)(_base213 + (42+37*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem213.skin.personaCapeOnClassic)); + *cast(ubyte*)(_base213 + (43+37*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem213.skin.isPrimaryUser)); + *cast(ubyte*)(_base213 + (44+37*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem213.skin.overrideAppearance)); + *cast(ubyte*)(_base213 + (45+37*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem213.skin.isTrusted)); + *cast(size_t*)(_base213 + (48+38*size_t.sizeof)) = cast(size_t)(_elem213.skin.profileHash.length); + *cast(void**)(_base213 + (48+37*size_t.sizeof)) = cast(void*)(cast(void*)(_elem213.skin.profileHash.ptr)); + *cast(ubyte*)(_base213 + (48+39*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem213.isTeacher)); + *cast(ubyte*)(_base213 + (49+39*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem213.isHost)); + *cast(ubyte*)(_base213 + (50+39*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem213.isSubClient)); + *cast(size_t*)(_base213 + (48+41*size_t.sizeof)) = cast(size_t)(_elem213.playerColor.length); + *cast(void**)(_base213 + (48+40*size_t.sizeof)) = cast(void*)(cast(void*)(_elem213.playerColor.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload212.entries.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(_list220); + break; + } + case _Tag301.cRemoveActor: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CRemoveActor _payload222 = packet.getCRemoveActor(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(35); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(cast(ulong)(_payload222.targetActorId)); + break; + } + case _Tag301.cRemoveObjective: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CRemoveObjective _payload224 = packet.getCRemoveObjective(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(36); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload224.objectiveName.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload224.objectiveName.ptr)); + break; + } + case _Tag301.cResourcePackStackPacket: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CResourcePackStackPacket _payload226 = packet.getCResourcePackStackPacket(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(37); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload226.texturePackRequired)); + auto _listSrc228 = _payload226.texturePackList; + auto _list228 = _listSrc228.length ? wit.common.malloc(_listSrc228.length * ((6*size_t.sizeof))) : null; + assert(!_listSrc228.length || _list228); + if (_listSrc228.length) deallocate ~= _list228; + foreach (_elem227_idx, ref _elem227; _listSrc228) { + auto _base227 = _list228 + _elem227_idx * ((6*size_t.sizeof)); + *cast(size_t*)(_base227 + size_t.sizeof) = cast(size_t)(_elem227.packId.length); + *cast(void**)(_base227 + 0) = cast(void*)(cast(void*)(_elem227.packId.ptr)); + *cast(size_t*)(_base227 + (3*size_t.sizeof)) = cast(size_t)(_elem227.version_.length); + *cast(void**)(_base227 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem227.version_.ptr)); + *cast(size_t*)(_base227 + (5*size_t.sizeof)) = cast(size_t)(_elem227.subPackName.length); + *cast(void**)(_base227 + (4*size_t.sizeof)) = cast(void*)(cast(void*)(_elem227.subPackName.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload226.texturePackList.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(_list228); + *cast(size_t*)(_retArea.ptr + (16+4*size_t.sizeof)) = cast(size_t)(_payload226.baseGameVersion.length); + *cast(void**)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload226.baseGameVersion.ptr)); + auto _listSrc230 = _payload226.experiments.toggles; + auto _list230 = _listSrc230.length ? wit.common.malloc(_listSrc230.length * ((3*size_t.sizeof))) : null; + assert(!_listSrc230.length || _list230); + if (_listSrc230.length) deallocate ~= _list230; + foreach (_elem229_idx, ref _elem229; _listSrc230) { + auto _base229 = _list230 + _elem229_idx * ((3*size_t.sizeof)); + *cast(size_t*)(_base229 + size_t.sizeof) = cast(size_t)(_elem229.name.length); + *cast(void**)(_base229 + 0) = cast(void*)(cast(void*)(_elem229.name.ptr)); + *cast(ubyte*)(_base229 + (2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem229.enabled)); + + } + *cast(size_t*)(_retArea.ptr + (16+6*size_t.sizeof)) = cast(size_t)(_payload226.experiments.toggles.length); + *cast(void**)(_retArea.ptr + (16+5*size_t.sizeof)) = cast(void*)(_list230); + *cast(ubyte*)(_retArea.ptr + (16+7*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload226.experiments.experimentsEverToggled)); + *cast(ubyte*)(_retArea.ptr + (16+8*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload226.includeEditorPacks)); + break; + } + case _Tag301.cResourcePacksInfo: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CResourcePacksInfo _payload232 = packet.getCResourcePacksInfo(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(38); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload232.resourcePackRequired)); + *cast(ubyte*)(_retArea.ptr + 17) = cast(ubyte)(cast(uint)(_payload232.hasAddonPacks)); + *cast(ubyte*)(_retArea.ptr + 18) = cast(ubyte)(cast(uint)(_payload232.hasScripts)); + *cast(ubyte*)(_retArea.ptr + 19) = cast(ubyte)(cast(uint)(_payload232.forceDisableVibrantVisuals)); + *cast(ulong*)(_retArea.ptr + 24) = cast(ulong)(_payload232.worldTemplateIdAndVersion.packUuid.high); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(_payload232.worldTemplateIdAndVersion.packUuid.low); + *cast(size_t*)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(size_t)(_payload232.worldTemplateIdAndVersion.packVersion.length); + *cast(void**)(_retArea.ptr + 40) = cast(void*)(cast(void*)(_payload232.worldTemplateIdAndVersion.packVersion.ptr)); + auto _listSrc234 = _payload232.resourcePacks; + auto _list234 = _listSrc234.length ? wit.common.malloc(_listSrc234.length * ((32+10*size_t.sizeof))) : null; + assert(!_listSrc234.length || _list234); + if (_listSrc234.length) deallocate ~= _list234; + foreach (_elem233_idx, ref _elem233; _listSrc234) { + auto _base233 = _list234 + _elem233_idx * ((32+10*size_t.sizeof)); + *cast(ulong*)(_base233 + 0) = cast(ulong)(_elem233.packIdVersion.packUuid.high); + *cast(ulong*)(_base233 + 8) = cast(ulong)(_elem233.packIdVersion.packUuid.low); + *cast(size_t*)(_base233 + (16+1*size_t.sizeof)) = cast(size_t)(_elem233.packIdVersion.packVersion.length); + *cast(void**)(_base233 + 16) = cast(void*)(cast(void*)(_elem233.packIdVersion.packVersion.ptr)); + *cast(ulong*)(_base233 + (16+2*size_t.sizeof)) = cast(ulong)(cast(ulong)(_elem233.packSize)); + *cast(size_t*)(_base233 + (24+3*size_t.sizeof)) = cast(size_t)(_elem233.contentKey.length); + *cast(void**)(_base233 + (24+2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem233.contentKey.ptr)); + *cast(size_t*)(_base233 + (24+5*size_t.sizeof)) = cast(size_t)(_elem233.subpackName.length); + *cast(void**)(_base233 + (24+4*size_t.sizeof)) = cast(void*)(cast(void*)(_elem233.subpackName.ptr)); + *cast(size_t*)(_base233 + (24+7*size_t.sizeof)) = cast(size_t)(_elem233.contentIdentity.length); + *cast(void**)(_base233 + (24+6*size_t.sizeof)) = cast(void*)(cast(void*)(_elem233.contentIdentity.ptr)); + *cast(ubyte*)(_base233 + (24+8*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem233.hasScripts)); + *cast(ubyte*)(_base233 + (25+8*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem233.isAddonPack)); + *cast(ubyte*)(_base233 + (26+8*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem233.isRayTracingCapable)); + *cast(size_t*)(_base233 + (24+10*size_t.sizeof)) = cast(size_t)(_elem233.cdnUrl.length); + *cast(void**)(_base233 + (24+9*size_t.sizeof)) = cast(void*)(cast(void*)(_elem233.cdnUrl.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(size_t)(_payload232.resourcePacks.length); + *cast(void**)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(void*)(_list234); + break; + } + case _Tag301.cSetActorData: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CSetActorData _payload236 = packet.getCSetActorData(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(39); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(cast(ulong)(_payload236.targetRuntimeId)); + *cast(size_t*)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(size_t)(_payload236.actorData.length); + *cast(void**)(_retArea.ptr + 24) = cast(void*)(cast(void*)(_payload236.actorData.ptr)); + *cast(size_t*)(_retArea.ptr + (24+3*size_t.sizeof)) = cast(size_t)(_payload236.syncedProperties.intEntriesList.length); + *cast(void**)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload236.syncedProperties.intEntriesList.ptr)); + *cast(size_t*)(_retArea.ptr + (24+5*size_t.sizeof)) = cast(size_t)(_payload236.syncedProperties.floatEntriesList.length); + *cast(void**)(_retArea.ptr + (24+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload236.syncedProperties.floatEntriesList.ptr)); + *cast(ulong*)(_retArea.ptr + (24+6*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload236.tick)); + break; + } + case _Tag301.cSetActorLink: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CSetActorLink _payload238 = packet.getCSetActorLink(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(40); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(cast(ulong)(_payload238.link.riddenUniqueId)); + *cast(ulong*)(_retArea.ptr + 24) = cast(ulong)(cast(ulong)(_payload238.link.riderUniqueId)); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload238.link.linkType)); + *cast(ubyte*)(_retArea.ptr + 33) = cast(ubyte)(cast(uint)(_payload238.link.immediate)); + *cast(ubyte*)(_retArea.ptr + 34) = cast(ubyte)(cast(uint)(_payload238.link.riderInitiated)); + *cast(float*)(_retArea.ptr + 36) = cast(float)(_payload238.link.vehicleAngularVelocity); + break; + } + case _Tag301.cSetActorMotion: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CSetActorMotion _payload240 = packet.getCSetActorMotion(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(41); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(cast(ulong)(_payload240.targetRuntimeId)); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload240.motion[0]); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload240.motion[1]); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload240.motion[2]); + *cast(ulong*)(_retArea.ptr + 48) = cast(ulong)(cast(ulong)(_payload240.tick)); + break; + } + case _Tag301.cSetDifficulty: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CSetDifficulty _payload242 = packet.getCSetDifficulty(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(42); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload242.difficulty)); + break; + } + case _Tag301.cSetDisplayObjective: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CSetDisplayObjective _payload244 = packet.getCSetDisplayObjective(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(43); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload244.displaySlotName.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload244.displaySlotName.ptr)); + *cast(size_t*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(size_t)(_payload244.objectiveName.length); + *cast(void**)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload244.objectiveName.ptr)); + *cast(size_t*)(_retArea.ptr + (16+5*size_t.sizeof)) = cast(size_t)(_payload244.objectiveDisplayName.length); + *cast(void**)(_retArea.ptr + (16+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload244.objectiveDisplayName.ptr)); + *cast(size_t*)(_retArea.ptr + (16+7*size_t.sizeof)) = cast(size_t)(_payload244.criteriaName.length); + *cast(void**)(_retArea.ptr + (16+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload244.criteriaName.ptr)); + *cast(uint*)(_retArea.ptr + (16+8*size_t.sizeof)) = cast(uint)(cast(uint)(_payload244.sortOrder)); + break; + } + case _Tag301.cSetHealth: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CSetHealth _payload246 = packet.getCSetHealth(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(44); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload246.health)); + break; + } + case _Tag301.cSetPlayerGameType: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CSetPlayerGameType _payload248 = packet.getCSetPlayerGameType(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(45); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload248.playerGameType)); + break; + } + case _Tag301.cSetScore: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CSetScore _payload250 = packet.getCSetScore(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(46); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload250.action)); + auto _listSrc252 = _payload250.entries; + auto _list252 = _listSrc252.length ? wit.common.malloc(_listSrc252.length * ((24+4*size_t.sizeof))) : null; + assert(!_listSrc252.length || _list252); + if (_listSrc252.length) deallocate ~= _list252; + foreach (_elem251_idx, ref _elem251; _listSrc252) { + auto _base251 = _list252 + _elem251_idx * ((24+4*size_t.sizeof)); + *cast(ulong*)(_base251 + 0) = cast(ulong)(cast(ulong)(_elem251.scoreboardId)); + *cast(size_t*)(_base251 + (8+1*size_t.sizeof)) = cast(size_t)(_elem251.objectiveName.length); + *cast(void**)(_base251 + 8) = cast(void*)(cast(void*)(_elem251.objectiveName.ptr)); + *cast(uint*)(_base251 + (8+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem251.score)); + *cast(uint*)(_base251 + (12+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem251.entryType)); + *cast(ulong*)(_base251 + (16+2*size_t.sizeof)) = cast(ulong)(cast(ulong)(_elem251.entityUniqueId)); + *cast(size_t*)(_base251 + (24+3*size_t.sizeof)) = cast(size_t)(_elem251.customName.length); + *cast(void**)(_base251 + (24+2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem251.customName.ptr)); + + } + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload250.entries.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(_list252); + break; + } + case _Tag301.cSetSpawnPosition: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CSetSpawnPosition _payload254 = packet.getCSetSpawnPosition(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(47); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload254.spawnPositionType)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload254.blockPosition[0])); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload254.blockPosition[1])); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload254.blockPosition[2])); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload254.dimensionType)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload254.spawnBlockPos[0])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload254.spawnBlockPos[1])); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload254.spawnBlockPos[2])); + break; + } + case _Tag301.cSetTime: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CSetTime _payload256 = packet.getCSetTime(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(48); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload256.time)); + break; + } + case _Tag301.cSetTitle: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CSetTitle _payload258 = packet.getCSetTitle(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(49); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload258.titleType)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload258.titleText.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload258.titleText.ptr)); + *cast(uint*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload258.fadeInTime)); + *cast(uint*)(_retArea.ptr + (20+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload258.stayTime)); + *cast(uint*)(_retArea.ptr + (24+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload258.fadeOutTime)); + *cast(size_t*)(_retArea.ptr + (24+5*size_t.sizeof)) = cast(size_t)(_payload258.xuid.length); + *cast(void**)(_retArea.ptr + (24+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload258.xuid.ptr)); + *cast(size_t*)(_retArea.ptr + (24+7*size_t.sizeof)) = cast(size_t)(_payload258.platformOnlineId.length); + *cast(void**)(_retArea.ptr + (24+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload258.platformOnlineId.ptr)); + *cast(size_t*)(_retArea.ptr + (24+9*size_t.sizeof)) = cast(size_t)(_payload258.filteredTitleMessage.length); + *cast(void**)(_retArea.ptr + (24+8*size_t.sizeof)) = cast(void*)(cast(void*)(_payload258.filteredTitleMessage.ptr)); + break; + } + case _Tag301.cShowCredits: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CShowCredits _payload260 = packet.getCShowCredits(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(50); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(cast(ulong)(_payload260.playerRuntimeId)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload260.creditsState)); + break; + } + case _Tag301.cStartGame: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CStartGame _payload262 = packet.getCStartGame(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(51); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(cast(ulong)(_payload262.entityId)); + *cast(ulong*)(_retArea.ptr + 24) = cast(ulong)(cast(ulong)(_payload262.runtimeEntityId)); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload262.playerGamemode)); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload262.position[0]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload262.position[1]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload262.position[2]); + *cast(float*)(_retArea.ptr + 64) = cast(float)(_payload262.pitch); + *cast(float*)(_retArea.ptr + 68) = cast(float)(_payload262.yaw); + *cast(ulong*)(_retArea.ptr + 72) = cast(ulong)(cast(ulong)(_payload262.levelSettings.seed)); + *cast(uint*)(_retArea.ptr + 80) = cast(uint)(cast(uint)(_payload262.levelSettings.spawnBiomeType)); + *cast(size_t*)(_retArea.ptr + (80+2*size_t.sizeof)) = cast(size_t)(_payload262.levelSettings.customBiomeName.length); + *cast(void**)(_retArea.ptr + (80+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload262.levelSettings.customBiomeName.ptr)); + *cast(uint*)(_retArea.ptr + (80+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload262.levelSettings.dimension)); + *cast(uint*)(_retArea.ptr + (84+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload262.levelSettings.generatorType)); + *cast(ubyte*)(_retArea.ptr + (88+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.worldGamemode)); + *cast(ubyte*)(_retArea.ptr + (89+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.hardcore)); + *cast(uint*)(_retArea.ptr + (92+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload262.levelSettings.difficulty)); + *cast(uint*)(_retArea.ptr + (96+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload262.levelSettings.spawnPosition[0])); + *cast(uint*)(_retArea.ptr + (100+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload262.levelSettings.spawnPosition[1])); + *cast(uint*)(_retArea.ptr + (104+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload262.levelSettings.spawnPosition[2])); + *cast(ubyte*)(_retArea.ptr + (108+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.hasAchievementsDisabled)); + *cast(uint*)(_retArea.ptr + (112+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload262.levelSettings.editorWorldType)); + *cast(ubyte*)(_retArea.ptr + (116+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.isCreatedInEditor)); + *cast(ubyte*)(_retArea.ptr + (117+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.isExportedFromEditor)); + *cast(uint*)(_retArea.ptr + (120+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload262.levelSettings.dayCycleStopTime)); + *cast(uint*)(_retArea.ptr + (124+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload262.levelSettings.educationEditionOffer)); + *cast(ubyte*)(_retArea.ptr + (128+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.hasEducationFeaturesEnabled)); + *cast(size_t*)(_retArea.ptr + (128+5*size_t.sizeof)) = cast(size_t)(_payload262.levelSettings.educationProductId.length); + *cast(void**)(_retArea.ptr + (128+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload262.levelSettings.educationProductId.ptr)); + *cast(float*)(_retArea.ptr + (128+6*size_t.sizeof)) = cast(float)(_payload262.levelSettings.rainLevel); + *cast(float*)(_retArea.ptr + (132+6*size_t.sizeof)) = cast(float)(_payload262.levelSettings.lightningLevel); + *cast(ubyte*)(_retArea.ptr + (136+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.hasConfirmedPlatformLockedContent)); + *cast(ubyte*)(_retArea.ptr + (137+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.wasMultiplayerIntended)); + *cast(ubyte*)(_retArea.ptr + (138+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.wasLanBroadcastingIntended)); + *cast(ubyte*)(_retArea.ptr + (139+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.xboxLiveBroadcastSetting)); + *cast(ubyte*)(_retArea.ptr + (140+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.platformBroadcastSetting)); + *cast(ubyte*)(_retArea.ptr + (141+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.commandsEnabled)); + *cast(ubyte*)(_retArea.ptr + (142+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.isTexturePacksRequired)); + auto _listSrc264 = _payload262.levelSettings.ruleData; + auto _list264 = _listSrc264.length ? wit.common.malloc(_listSrc264.length * ((3*size_t.sizeof))) : null; + assert(!_listSrc264.length || _list264); + if (_listSrc264.length) deallocate ~= _list264; + foreach (_elem263_idx, ref _elem263; _listSrc264) { + auto _base263 = _list264 + _elem263_idx * ((3*size_t.sizeof)); + *cast(size_t*)(_base263 + size_t.sizeof) = cast(size_t)(_elem263.ruleName.length); + *cast(void**)(_base263 + 0) = cast(void*)(cast(void*)(_elem263.ruleName.ptr)); + *cast(ubyte*)(_base263 + (2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem263.ruleCanBeModified)); + *cast(ubyte*)(_base263 + (1+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem263.ruleValue)); + + } + *cast(size_t*)(_retArea.ptr + (144+7*size_t.sizeof)) = cast(size_t)(_payload262.levelSettings.ruleData.length); + *cast(void**)(_retArea.ptr + (144+6*size_t.sizeof)) = cast(void*)(_list264); + auto _listSrc266 = _payload262.levelSettings.experiments.toggles; + auto _list266 = _listSrc266.length ? wit.common.malloc(_listSrc266.length * ((3*size_t.sizeof))) : null; + assert(!_listSrc266.length || _list266); + if (_listSrc266.length) deallocate ~= _list266; + foreach (_elem265_idx, ref _elem265; _listSrc266) { + auto _base265 = _list266 + _elem265_idx * ((3*size_t.sizeof)); + *cast(size_t*)(_base265 + size_t.sizeof) = cast(size_t)(_elem265.name.length); + *cast(void**)(_base265 + 0) = cast(void*)(cast(void*)(_elem265.name.ptr)); + *cast(ubyte*)(_base265 + (2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem265.enabled)); + + } + *cast(size_t*)(_retArea.ptr + (144+9*size_t.sizeof)) = cast(size_t)(_payload262.levelSettings.experiments.toggles.length); + *cast(void**)(_retArea.ptr + (144+8*size_t.sizeof)) = cast(void*)(_list266); + *cast(ubyte*)(_retArea.ptr + (144+10*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.experiments.experimentsEverToggled)); + *cast(ubyte*)(_retArea.ptr + (144+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.bonusChest)); + *cast(ubyte*)(_retArea.ptr + (145+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.hasStartWithMapEnabled)); + *cast(ubyte*)(_retArea.ptr + (146+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.permissionLevel)); + *cast(uint*)(_retArea.ptr + (148+11*size_t.sizeof)) = cast(uint)(cast(uint)(_payload262.levelSettings.serverSimulationDistance)); + *cast(ubyte*)(_retArea.ptr + (152+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.hasLockedBehaviorPack)); + *cast(ubyte*)(_retArea.ptr + (153+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.hasLockedResourcePack)); + *cast(ubyte*)(_retArea.ptr + (154+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.isFromLockedWorldTemplate)); + *cast(ubyte*)(_retArea.ptr + (155+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.isUsingMsaGamertagsOnly)); + *cast(ubyte*)(_retArea.ptr + (156+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.isFromWorldTemplate)); + *cast(ubyte*)(_retArea.ptr + (157+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.isWorldTemplateOptionLocked)); + *cast(ubyte*)(_retArea.ptr + (158+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.isOnlySpawningV1Villagers)); + *cast(ubyte*)(_retArea.ptr + (159+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.isDisablingPersonas)); + *cast(ubyte*)(_retArea.ptr + (160+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.isDisablingCustomSkins)); + *cast(ubyte*)(_retArea.ptr + (161+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.emoteChatMuted)); + *cast(size_t*)(_retArea.ptr + (160+13*size_t.sizeof)) = cast(size_t)(_payload262.levelSettings.gameVersion.length); + *cast(void**)(_retArea.ptr + (160+12*size_t.sizeof)) = cast(void*)(cast(void*)(_payload262.levelSettings.gameVersion.ptr)); + *cast(uint*)(_retArea.ptr + (160+14*size_t.sizeof)) = cast(uint)(cast(uint)(_payload262.levelSettings.limitedWorldWidth)); + *cast(uint*)(_retArea.ptr + (164+14*size_t.sizeof)) = cast(uint)(cast(uint)(_payload262.levelSettings.limitedWorldHeight)); + *cast(ubyte*)(_retArea.ptr + (168+14*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.newNether)); + *cast(size_t*)(_retArea.ptr + (168+16*size_t.sizeof)) = cast(size_t)(_payload262.levelSettings.eduSharedUriButtonName.length); + *cast(void**)(_retArea.ptr + (168+15*size_t.sizeof)) = cast(void*)(cast(void*)(_payload262.levelSettings.eduSharedUriButtonName.ptr)); + *cast(size_t*)(_retArea.ptr + (168+18*size_t.sizeof)) = cast(size_t)(_payload262.levelSettings.eduSharedUriLinkUri.length); + *cast(void**)(_retArea.ptr + (168+17*size_t.sizeof)) = cast(void*)(cast(void*)(_payload262.levelSettings.eduSharedUriLinkUri.ptr)); + *cast(ubyte*)(_retArea.ptr + (168+19*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.overrideForceExperimentalGameplayHasValue)); + *cast(ubyte*)(_retArea.ptr + (169+19*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.chatRestrictionLevel)); + *cast(ubyte*)(_retArea.ptr + (170+19*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.disablePlayerInteractions)); + *cast(uint*)(_retArea.ptr + (172+19*size_t.sizeof)) = cast(uint)(cast(uint)(_payload262.levelSettings.serverEditorConnectionPolicy)); + *cast(ubyte*)(_retArea.ptr + (176+19*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.levelSettings.allowAnonymousBlockDropsInEditorWorlds)); + *cast(size_t*)(_retArea.ptr + (176+21*size_t.sizeof)) = cast(size_t)(_payload262.levelId.length); + *cast(void**)(_retArea.ptr + (176+20*size_t.sizeof)) = cast(void*)(cast(void*)(_payload262.levelId.ptr)); + *cast(size_t*)(_retArea.ptr + (176+23*size_t.sizeof)) = cast(size_t)(_payload262.levelName.length); + *cast(void**)(_retArea.ptr + (176+22*size_t.sizeof)) = cast(void*)(cast(void*)(_payload262.levelName.ptr)); + *cast(size_t*)(_retArea.ptr + (176+25*size_t.sizeof)) = cast(size_t)(_payload262.premiumWorldTemplateId.length); + *cast(void**)(_retArea.ptr + (176+24*size_t.sizeof)) = cast(void*)(cast(void*)(_payload262.premiumWorldTemplateId.ptr)); + *cast(ubyte*)(_retArea.ptr + (176+26*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.isTrial)); + *cast(uint*)(_retArea.ptr + (180+26*size_t.sizeof)) = cast(uint)(cast(uint)(_payload262.rewindHistorySize)); + *cast(ubyte*)(_retArea.ptr + (184+26*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.serverAuthoritativeBlockBreaking)); + *cast(ulong*)(_retArea.ptr + (192+26*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload262.currentLevelTime)); + *cast(uint*)(_retArea.ptr + (200+26*size_t.sizeof)) = cast(uint)(cast(uint)(_payload262.enchantmentSeed)); + *cast(uint*)(_retArea.ptr + (204+26*size_t.sizeof)) = cast(uint)(cast(uint)(_payload262.blockPropertiesSize)); + *cast(size_t*)(_retArea.ptr + (208+27*size_t.sizeof)) = cast(size_t)(_payload262.multiplayerCorrelationId.length); + *cast(void**)(_retArea.ptr + (208+26*size_t.sizeof)) = cast(void*)(cast(void*)(_payload262.multiplayerCorrelationId.ptr)); + *cast(ubyte*)(_retArea.ptr + (208+28*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.enableItemstackNetManager)); + *cast(size_t*)(_retArea.ptr + (208+30*size_t.sizeof)) = cast(size_t)(_payload262.serverVersion.length); + *cast(void**)(_retArea.ptr + (208+29*size_t.sizeof)) = cast(void*)(cast(void*)(_payload262.serverVersion.ptr)); + *cast(ubyte*)(_retArea.ptr + (208+31*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.compoundId)); + *cast(uint*)(_retArea.ptr + (212+31*size_t.sizeof)) = cast(uint)(cast(uint)(_payload262.compoundLen)); + *cast(ubyte*)(_retArea.ptr + (216+31*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.compoundEnd)); + *cast(ulong*)(_retArea.ptr + (216+32*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload262.blockRegistryChecksum)); + *cast(ulong*)(_retArea.ptr + (224+32*size_t.sizeof)) = cast(ulong)(_payload262.worldTemplateId.high); + *cast(ulong*)(_retArea.ptr + (232+32*size_t.sizeof)) = cast(ulong)(_payload262.worldTemplateId.low); + *cast(ubyte*)(_retArea.ptr + (240+32*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.enableClientsideGeneration)); + *cast(ubyte*)(_retArea.ptr + (241+32*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.blocknetworkIdsAreHashed)); + *cast(ubyte*)(_retArea.ptr + (242+32*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload262.serverAuthSounds)); + if (_payload262.serverJoinInformation.isSome) { + ref _payload270 = _payload262.serverJoinInformation.unwrap(); + *cast(ubyte*)(_retArea.ptr + (248+32*size_t.sizeof)) = cast(ubyte)(1); + if (_payload270.gathering.isSome) { + ref _payload274 = _payload270.gathering.unwrap(); + *cast(ubyte*)(_retArea.ptr + (256+32*size_t.sizeof)) = cast(ubyte)(1); + *cast(ulong*)(_retArea.ptr + (264+32*size_t.sizeof)) = cast(ulong)(_payload274.experienceId.high); + *cast(ulong*)(_retArea.ptr + (272+32*size_t.sizeof)) = cast(ulong)(_payload274.experienceId.low); + *cast(size_t*)(_retArea.ptr + (280+33*size_t.sizeof)) = cast(size_t)(_payload274.experienceName.length); + *cast(void**)(_retArea.ptr + (280+32*size_t.sizeof)) = cast(void*)(cast(void*)(_payload274.experienceName.ptr)); + *cast(ulong*)(_retArea.ptr + (280+34*size_t.sizeof)) = cast(ulong)(_payload274.experienceWorldId.high); + *cast(ulong*)(_retArea.ptr + (288+34*size_t.sizeof)) = cast(ulong)(_payload274.experienceWorldId.low); + *cast(size_t*)(_retArea.ptr + (296+35*size_t.sizeof)) = cast(size_t)(_payload274.experienceWorldName.length); + *cast(void**)(_retArea.ptr + (296+34*size_t.sizeof)) = cast(void*)(cast(void*)(_payload274.experienceWorldName.ptr)); + *cast(size_t*)(_retArea.ptr + (296+37*size_t.sizeof)) = cast(size_t)(_payload274.creatorId.length); + *cast(void**)(_retArea.ptr + (296+36*size_t.sizeof)) = cast(void*)(cast(void*)(_payload274.creatorId.ptr)); + *cast(ulong*)(_retArea.ptr + (296+38*size_t.sizeof)) = cast(ulong)(_payload274.unknownUuid1.high); + *cast(ulong*)(_retArea.ptr + (304+38*size_t.sizeof)) = cast(ulong)(_payload274.unknownUuid1.low); + *cast(ulong*)(_retArea.ptr + (312+38*size_t.sizeof)) = cast(ulong)(_payload274.unknownUuid2.high); + *cast(ulong*)(_retArea.ptr + (320+38*size_t.sizeof)) = cast(ulong)(_payload274.unknownUuid2.low); + *cast(size_t*)(_retArea.ptr + (328+39*size_t.sizeof)) = cast(size_t)(_payload274.serverId.length); + *cast(void**)(_retArea.ptr + (328+38*size_t.sizeof)) = cast(void*)(cast(void*)(_payload274.serverId.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (256+32*size_t.sizeof)) = cast(ubyte)(0); + } + if (_payload270.storeEntryPoint.isSome) { + ref _payload278 = _payload270.storeEntryPoint.unwrap(); + *cast(ubyte*)(_retArea.ptr + (328+40*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (328+42*size_t.sizeof)) = cast(size_t)(_payload278.storeId.length); + *cast(void**)(_retArea.ptr + (328+41*size_t.sizeof)) = cast(void*)(cast(void*)(_payload278.storeId.ptr)); + *cast(size_t*)(_retArea.ptr + (328+44*size_t.sizeof)) = cast(size_t)(_payload278.storeName.length); + *cast(void**)(_retArea.ptr + (328+43*size_t.sizeof)) = cast(void*)(cast(void*)(_payload278.storeName.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (328+40*size_t.sizeof)) = cast(ubyte)(0); + } + if (_payload270.presence.isSome) { + ref _payload282 = _payload270.presence.unwrap(); + *cast(ubyte*)(_retArea.ptr + (328+45*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (328+47*size_t.sizeof)) = cast(size_t)(_payload282.experienceName.length); + *cast(void**)(_retArea.ptr + (328+46*size_t.sizeof)) = cast(void*)(cast(void*)(_payload282.experienceName.ptr)); + *cast(size_t*)(_retArea.ptr + (328+49*size_t.sizeof)) = cast(size_t)(_payload282.worldName.length); + *cast(void**)(_retArea.ptr + (328+48*size_t.sizeof)) = cast(void*)(cast(void*)(_payload282.worldName.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (328+45*size_t.sizeof)) = cast(ubyte)(0); + } + } else { + *cast(ubyte*)(_retArea.ptr + (248+32*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(size_t*)(_retArea.ptr + (328+51*size_t.sizeof)) = cast(size_t)(_payload262.telemetry.serverId.length); + *cast(void**)(_retArea.ptr + (328+50*size_t.sizeof)) = cast(void*)(cast(void*)(_payload262.telemetry.serverId.ptr)); + *cast(size_t*)(_retArea.ptr + (328+53*size_t.sizeof)) = cast(size_t)(_payload262.telemetry.scenarioId.length); + *cast(void**)(_retArea.ptr + (328+52*size_t.sizeof)) = cast(void*)(cast(void*)(_payload262.telemetry.scenarioId.ptr)); + *cast(size_t*)(_retArea.ptr + (328+55*size_t.sizeof)) = cast(size_t)(_payload262.telemetry.worldId.length); + *cast(void**)(_retArea.ptr + (328+54*size_t.sizeof)) = cast(void*)(cast(void*)(_payload262.telemetry.worldId.ptr)); + *cast(size_t*)(_retArea.ptr + (328+57*size_t.sizeof)) = cast(size_t)(_payload262.telemetry.ownerId.length); + *cast(void**)(_retArea.ptr + (328+56*size_t.sizeof)) = cast(void*)(cast(void*)(_payload262.telemetry.ownerId.ptr)); + break; + } + case _Tag301.cTakeItemActor: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CTakeItemActor _payload284 = packet.getCTakeItemActor(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(52); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(cast(ulong)(_payload284.itemRuntimeId)); + *cast(ulong*)(_retArea.ptr + 24) = cast(ulong)(cast(ulong)(_payload284.actorRuntimeId)); + break; + } + case _Tag301.cTransfer: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CTransfer _payload286 = packet.getCTransfer(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(53); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload286.serverAddress.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload286.serverAddress.ptr)); + *cast(uint*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload286.serverPort)); + *cast(ubyte*)(_retArea.ptr + (20+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload286.reloadWorld)); + break; + } + case _Tag301.cUpdateAbilities: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CUpdateAbilities _payload288 = packet.getCUpdateAbilities(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(54); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(cast(ulong)(_payload288.data.targetPlayerRawId)); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload288.data.playerPermissions)); + *cast(ubyte*)(_retArea.ptr + 25) = cast(ubyte)(cast(uint)(_payload288.data.commandPermissions)); + *cast(size_t*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(size_t)(_payload288.data.layers.length); + *cast(void**)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload288.data.layers.ptr)); + break; + } + case _Tag301.cUpdateAttributes: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CUpdateAttributes _payload290 = packet.getCUpdateAttributes(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(55); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(cast(ulong)(_payload290.targetRuntimeId)); + auto _listSrc294 = _payload290.attributeList; + auto _list294 = _listSrc294.length ? wit.common.malloc(_listSrc294.length * ((24+4*size_t.sizeof))) : null; + assert(!_listSrc294.length || _list294); + if (_listSrc294.length) deallocate ~= _list294; + foreach (_elem291_idx, ref _elem291; _listSrc294) { + auto _base291 = _list294 + _elem291_idx * ((24+4*size_t.sizeof)); + *cast(float*)(_base291 + 0) = cast(float)(_elem291.minValue); + *cast(float*)(_base291 + 4) = cast(float)(_elem291.maxValue); + *cast(float*)(_base291 + 8) = cast(float)(_elem291.currentValue); + *cast(float*)(_base291 + 12) = cast(float)(_elem291.defaultMinValue); + *cast(float*)(_base291 + 16) = cast(float)(_elem291.defaultMaxValue); + *cast(float*)(_base291 + 20) = cast(float)(_elem291.defaultValue); + *cast(size_t*)(_base291 + (24+1*size_t.sizeof)) = cast(size_t)(_elem291.name.length); + *cast(void**)(_base291 + 24) = cast(void*)(cast(void*)(_elem291.name.ptr)); + auto _listSrc293 = _elem291.modifiers; + auto _list293 = _listSrc293.length ? wit.common.malloc(_listSrc293.length * ((16+4*size_t.sizeof))) : null; + assert(!_listSrc293.length || _list293); + if (_listSrc293.length) deallocate ~= _list293; + foreach (_elem292_idx, ref _elem292; _listSrc293) { + auto _base292 = _list293 + _elem292_idx * ((16+4*size_t.sizeof)); + *cast(size_t*)(_base292 + size_t.sizeof) = cast(size_t)(_elem292.id.length); + *cast(void**)(_base292 + 0) = cast(void*)(cast(void*)(_elem292.id.ptr)); + *cast(size_t*)(_base292 + (3*size_t.sizeof)) = cast(size_t)(_elem292.name.length); + *cast(void**)(_base292 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem292.name.ptr)); + *cast(float*)(_base292 + (4*size_t.sizeof)) = cast(float)(_elem292.amount); + *cast(uint*)(_base292 + (4+4*size_t.sizeof)) = cast(uint)(cast(uint)(_elem292.operation)); + *cast(uint*)(_base292 + (8+4*size_t.sizeof)) = cast(uint)(cast(uint)(_elem292.operand)); + *cast(ubyte*)(_base292 + (12+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem292.isSerializable)); + + } + *cast(size_t*)(_base291 + (24+3*size_t.sizeof)) = cast(size_t)(_elem291.modifiers.length); + *cast(void**)(_base291 + (24+2*size_t.sizeof)) = cast(void*)(_list293); + + } + *cast(size_t*)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(size_t)(_payload290.attributeList.length); + *cast(void**)(_retArea.ptr + 24) = cast(void*)(_list294); + *cast(ulong*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload290.tick)); + break; + } + case _Tag301.cUpdateBlock: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CUpdateBlock _payload296 = packet.getCUpdateBlock(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(56); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload296.blockPosition[0])); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload296.blockPosition[1])); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload296.blockPosition[2])); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload296.blockRuntimeId)); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload296.flags)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload296.layer)); + break; + } + case _Tag301.cUpdateTrade: { + const ref wit.pumpkin.plugin.bedrock_packets.imports.CUpdateTrade _payload298 = packet.getCUpdateTrade(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(57); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload298.containerId)); + *cast(ubyte*)(_retArea.ptr + 17) = cast(ubyte)(cast(uint)(_payload298.rType)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload298.size)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload298.traderTier)); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload298.entityUniqueId)); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(cast(ulong)(_payload298.lastTradingPlayer)); + *cast(size_t*)(_retArea.ptr + (48+1*size_t.sizeof)) = cast(size_t)(_payload298.displayName.length); + *cast(void**)(_retArea.ptr + 48) = cast(void*)(cast(void*)(_payload298.displayName.ptr)); + *cast(ubyte*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload298.useNewTradeScreen)); + *cast(ubyte*)(_retArea.ptr + (49+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload298.usingEconomyTrade)); + *cast(size_t*)(_retArea.ptr + (48+4*size_t.sizeof)) = cast(size_t)(_payload298.data.length); + *cast(void**)(_retArea.ptr + (48+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload298.data.ptr)); + break; + } + case _Tag301.unknown: { + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(58); + break; + } + } + __import_sendPacket(_retArea.ptr); + deallocate.purge(); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]bedrock-player.send-packet") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:bedrock_player.send_packet") + static private extern(C) void __import_sendPacket(void*) nothrow; + + /++ + Opens a Bedrock custom form for the player. + +/ + uint openForm(in Form form) @trusted nothrow { + wit.common.DeallocateBuffer deallocate; + uint _variantPart31 = void; + uint _variantPart32 = void; + void* _variantPart33 = void; + void* _variantPart34 = void; + size_t _variantPart35 = void; + alias _Tag36 = wit.pumpkin.plugin.forms.imports.Form.Tag; + final switch (form.tag) { + case _Tag36.simple: { + const ref wit.pumpkin.plugin.forms.imports.SimpleForm _payload1 = form.getSimple(); + auto _listSrc7 = _payload1.buttons; + auto _list7 = _listSrc7.length ? wit.common.malloc(_listSrc7.length * ((5*size_t.sizeof))) : null; + assert(!_listSrc7.length || _list7); + if (_listSrc7.length) deallocate ~= _list7; + foreach (_elem2_idx, ref _elem2; _listSrc7) { + auto _base2 = _list7 + _elem2_idx * ((5*size_t.sizeof)); + *cast(uint*)(_base2 + 0) = cast(uint)(_elem2.text.__handle); + if (_elem2.image.isSome) { + ref _payload6 = _elem2.image.unwrap(); + *cast(ubyte*)(_base2 + size_t.sizeof) = cast(ubyte)(1); + *cast(ubyte*)(_base2 + (2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6.type)); + *cast(size_t*)(_base2 + (4*size_t.sizeof)) = cast(size_t)(_payload6.data.length); + *cast(void**)(_base2 + (3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6.data.ptr)); + } else { + *cast(ubyte*)(_base2 + size_t.sizeof) = cast(ubyte)(0); + } + + } + _variantPart31 = 0; + _variantPart32 = _payload1.title.__handle; + _variantPart33 = cast(void*)(_payload1.content.__handle); + _variantPart34 = _list7; + _variantPart35 = _payload1.buttons.length; + break; + } + case _Tag36.modal: { + const ref wit.pumpkin.plugin.forms.imports.ModalForm _payload9 = form.getModal(); + _variantPart31 = 1; + _variantPart32 = _payload9.title.__handle; + _variantPart33 = cast(void*)(_payload9.content.__handle); + _variantPart34 = cast(void*)(_payload9.button1.__handle); + _variantPart35 = cast(size_t)(_payload9.button2.__handle); + break; + } + case _Tag36.custom: { + const ref wit.pumpkin.plugin.forms.imports.CustomForm _payload11 = form.getCustom(); + auto _listSrc30 = _payload11.elements; + auto _list30 = _listSrc30.length ? wit.common.malloc(_listSrc30.length * ((6*size_t.sizeof))) : null; + assert(!_listSrc30.length || _list30); + if (_listSrc30.length) deallocate ~= _list30; + foreach (_elem12_idx, ref _elem12; _listSrc30) { + auto _base12 = _list30 + _elem12_idx * ((6*size_t.sizeof)); + alias _Tag29 = wit.pumpkin.plugin.forms.imports.CustomFormElement.Tag; + final switch (_elem12.tag) { + case _Tag29.label: { + const ref wit.pumpkin.plugin.forms.imports.TextComponent _payload14 = _elem12.getLabel(); + *cast(ubyte*)(_base12 + 0) = cast(ubyte)(0); + *cast(uint*)(_base12 + size_t.sizeof) = cast(uint)(_payload14.__handle); + break; + } + case _Tag29.toggle: { + const ref Tuple!(wit.pumpkin.plugin.forms.imports.TextComponent, bool) _payload16 = _elem12.getToggle(); + *cast(ubyte*)(_base12 + 0) = cast(ubyte)(1); + *cast(uint*)(_base12 + size_t.sizeof) = cast(uint)(_payload16[0].__handle); + *cast(ubyte*)(_base12 + (4+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload16[1])); + break; + } + case _Tag29.slider: { + const ref Tuple!(wit.pumpkin.plugin.forms.imports.TextComponent, float, float, float, float) _payload18 = _elem12.getSlider(); + *cast(ubyte*)(_base12 + 0) = cast(ubyte)(2); + *cast(uint*)(_base12 + size_t.sizeof) = cast(uint)(_payload18[0].__handle); + *cast(float*)(_base12 + (4+1*size_t.sizeof)) = cast(float)(_payload18[1]); + *cast(float*)(_base12 + (8+1*size_t.sizeof)) = cast(float)(_payload18[2]); + *cast(float*)(_base12 + (12+1*size_t.sizeof)) = cast(float)(_payload18[3]); + *cast(float*)(_base12 + (16+1*size_t.sizeof)) = cast(float)(_payload18[4]); + break; + } + case _Tag29.stepSlider: { + const ref Tuple!(wit.pumpkin.plugin.forms.imports.TextComponent, WitList!(WitString), uint) _payload20 = _elem12.getStepSlider(); + *cast(ubyte*)(_base12 + 0) = cast(ubyte)(3); + *cast(uint*)(_base12 + size_t.sizeof) = cast(uint)(_payload20[0].__handle); + auto _listSrc22 = _payload20[1]; + auto _list22 = _listSrc22.length ? wit.common.malloc(_listSrc22.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc22.length || _list22); + if (_listSrc22.length) deallocate ~= _list22; + foreach (_elem21_idx, ref _elem21; _listSrc22) { + auto _base21 = _list22 + _elem21_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base21 + size_t.sizeof) = cast(size_t)(_elem21.length); + *cast(void**)(_base21 + 0) = cast(void*)(cast(void*)(_elem21.ptr)); + + } + *cast(size_t*)(_base12 + (3*size_t.sizeof)) = cast(size_t)(_payload20[1].length); + *cast(void**)(_base12 + (2*size_t.sizeof)) = cast(void*)(_list22); + *cast(uint*)(_base12 + (4*size_t.sizeof)) = cast(uint)(_payload20[2]); + break; + } + case _Tag29.dropdown: { + const ref Tuple!(wit.pumpkin.plugin.forms.imports.TextComponent, WitList!(WitString), uint) _payload24 = _elem12.getDropdown(); + *cast(ubyte*)(_base12 + 0) = cast(ubyte)(4); + *cast(uint*)(_base12 + size_t.sizeof) = cast(uint)(_payload24[0].__handle); + auto _listSrc26 = _payload24[1]; + auto _list26 = _listSrc26.length ? wit.common.malloc(_listSrc26.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc26.length || _list26); + if (_listSrc26.length) deallocate ~= _list26; + foreach (_elem25_idx, ref _elem25; _listSrc26) { + auto _base25 = _list26 + _elem25_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base25 + size_t.sizeof) = cast(size_t)(_elem25.length); + *cast(void**)(_base25 + 0) = cast(void*)(cast(void*)(_elem25.ptr)); + + } + *cast(size_t*)(_base12 + (3*size_t.sizeof)) = cast(size_t)(_payload24[1].length); + *cast(void**)(_base12 + (2*size_t.sizeof)) = cast(void*)(_list26); + *cast(uint*)(_base12 + (4*size_t.sizeof)) = cast(uint)(_payload24[2]); + break; + } + case _Tag29.input: { + const ref Tuple!(wit.pumpkin.plugin.forms.imports.TextComponent, WitString, WitString) _payload28 = _elem12.getInput(); + *cast(ubyte*)(_base12 + 0) = cast(ubyte)(5); + *cast(uint*)(_base12 + size_t.sizeof) = cast(uint)(_payload28[0].__handle); + *cast(size_t*)(_base12 + (3*size_t.sizeof)) = cast(size_t)(_payload28[1].length); + *cast(void**)(_base12 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload28[1].ptr)); + *cast(size_t*)(_base12 + (5*size_t.sizeof)) = cast(size_t)(_payload28[2].length); + *cast(void**)(_base12 + (4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload28[2].ptr)); + break; + } + } + + } + _variantPart31 = 2; + _variantPart32 = _payload11.title.__handle; + _variantPart33 = _list30; + _variantPart34 = cast(void*)(_payload11.elements.length); + _variantPart35 = 0; + break; + } + } + auto _ret = __import_openForm(this.__handle, _variantPart31, _variantPart32, _variantPart33, _variantPart34, _variantPart35); + deallocate.purge(); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]bedrock-player.open-form") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:bedrock_player.open_form") + static private extern(C) uint __import_openForm(uint, uint, uint, void*, void*, size_t) nothrow; + + /++ + Returns the Bedrock scoreboard handle for this player. + +/ + BedrockScoreboard getScoreboard() @trusted nothrow { + auto _ret = __import_getScoreboard(this.__handle); + auto _handle0 = BedrockScoreboard(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]bedrock-player.get-scoreboard") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:bedrock_player.get_scoreboard") + static private extern(C) uint __import_getScoreboard(uint) nothrow; + + /++ + Resets the player's custom Bedrock scoreboard back to the world scoreboard. + +/ + void resetScoreboard() @trusted nothrow { + __import_resetScoreboard(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]bedrock-player.reset-scoreboard") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:bedrock_player.reset_scoreboard") + static private extern(C) void __import_resetScoreboard(uint) nothrow; + + /++ + Sends resource packs information to the Bedrock player. + +/ + void sendResourcePacksInfo(in BedrockResourcePacksInfo info) @trusted nothrow { + wit.common.DeallocateBuffer deallocate; + uint _option4 = void; + ulong _option5 = void; + ulong _option6 = void; + if (info.worldTemplateId.isSome) { + ref _payload3 = info.worldTemplateId.unwrap(); + _option4 = 1; + _option5 = _payload3.high; + _option6 = _payload3.low; + } else { + _option4 = 0; + _option5 = 0; + _option6 = 0; + } + uint _option11 = void; + void* _option12 = void; + size_t _option13 = void; + if (info.worldTemplateVersion.isSome) { + ref _payload10 = info.worldTemplateVersion.unwrap(); + _option11 = 1; + _option12 = cast(void*)(_payload10.ptr); + _option13 = _payload10.length; + } else { + _option11 = 0; + _option12 = null; + _option13 = 0; + } + auto _listSrc27 = info.packs; + auto _list27 = _listSrc27.length ? wit.common.malloc(_listSrc27.length * ((24+14*size_t.sizeof))) : null; + assert(!_listSrc27.length || _list27); + if (_listSrc27.length) deallocate ~= _list27; + foreach (_elem14_idx, ref _elem14; _listSrc27) { + auto _base14 = _list27 + _elem14_idx * ((24+14*size_t.sizeof)); + *cast(ulong*)(_base14 + 0) = cast(ulong)(_elem14.id.high); + *cast(ulong*)(_base14 + 8) = cast(ulong)(_elem14.id.low); + *cast(size_t*)(_base14 + (16+1*size_t.sizeof)) = cast(size_t)(_elem14.version_.length); + *cast(void**)(_base14 + 16) = cast(void*)(cast(void*)(_elem14.version_.ptr)); + *cast(ulong*)(_base14 + (16+2*size_t.sizeof)) = cast(ulong)(_elem14.size); + *cast(size_t*)(_base14 + (24+3*size_t.sizeof)) = cast(size_t)(_elem14.downloadUrl.length); + *cast(void**)(_base14 + (24+2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem14.downloadUrl.ptr)); + if (_elem14.contentKey.isSome) { + ref _payload18 = _elem14.contentKey.unwrap(); + *cast(ubyte*)(_base14 + (24+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_base14 + (24+6*size_t.sizeof)) = cast(size_t)(_payload18.length); + *cast(void**)(_base14 + (24+5*size_t.sizeof)) = cast(void*)(cast(void*)(_payload18.ptr)); + } else { + *cast(ubyte*)(_base14 + (24+4*size_t.sizeof)) = cast(ubyte)(0); + } + if (_elem14.subPackName.isSome) { + ref _payload22 = _elem14.subPackName.unwrap(); + *cast(ubyte*)(_base14 + (24+7*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_base14 + (24+9*size_t.sizeof)) = cast(size_t)(_payload22.length); + *cast(void**)(_base14 + (24+8*size_t.sizeof)) = cast(void*)(cast(void*)(_payload22.ptr)); + } else { + *cast(ubyte*)(_base14 + (24+7*size_t.sizeof)) = cast(ubyte)(0); + } + if (_elem14.contentId.isSome) { + ref _payload26 = _elem14.contentId.unwrap(); + *cast(ubyte*)(_base14 + (24+10*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_base14 + (24+12*size_t.sizeof)) = cast(size_t)(_payload26.length); + *cast(void**)(_base14 + (24+11*size_t.sizeof)) = cast(void*)(cast(void*)(_payload26.ptr)); + } else { + *cast(ubyte*)(_base14 + (24+10*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base14 + (24+13*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem14.hasScripts)); + *cast(ubyte*)(_base14 + (25+13*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem14.addonPack)); + *cast(ubyte*)(_base14 + (26+13*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem14.rtxEnabled)); + + } + __import_sendResourcePacksInfo(this.__handle, cast(uint)(info.required), cast(uint)(info.hasAddonPacks), cast(uint)(info.hasScripts), cast(uint)(info.isVibrantVisualsForceDisabled), _option4, _option5, _option6, _option11, _option12, _option13, _list27, info.packs.length); + deallocate.purge(); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]bedrock-player.send-resource-packs-info") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:bedrock_player.send_resource_packs_info") + static private extern(C) void __import_sendResourcePacksInfo(uint, uint, uint, uint, uint, uint, ulong, ulong, uint, void*, size_t, void*, size_t) nothrow; + + /++ + Kicks the Bedrock player with the specified options. + +/ + void kick(in BedrockKickOptions options) @trusted nothrow { + __import_kick(this.__handle, cast(uint)(options.reason), cast(void*)(options.message.ptr), options.message.length, cast(uint)(options.skipMessage), cast(void*)(options.filteredMessage.ptr), options.filteredMessage.length, cast(uint)(options.logToConsole), cast(uint)(options.teardownPolicy)); + } + /// ditto + @wasmImport!("pumpkin:plugin/player@0.1.0", "[method]bedrock-player.kick") + pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__:method:bedrock_player.kick") + static private extern(C) void __import_kick(uint, uint, void*, size_t, uint, void*, size_t, uint, uint) nothrow; + } +} + +/++ +Returns a list of all players in a specific world. ++/ +WitList!(Player) getWorldPlayers(World worldRef) @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getWorldPlayers(worldRef.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(Player*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitList!(Player)(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; +} +/// ditto +@wasmImport!("pumpkin:plugin/player@0.1.0", "get-world-players") +pragma(mangle, "__wit_import_pumpkin:plugin__player@0.1.0__get_world_players") +private extern(C) void __import_getWorldPlayers(uint, void*) nothrow; diff --git a/src/wit/pumpkin/plugin/plugin/package.d b/src/wit/pumpkin/plugin/plugin/package.d new file mode 100644 index 0000000..61aa38d --- /dev/null +++ b/src/wit/pumpkin/plugin/plugin/package.d @@ -0,0 +1,37353 @@ +/++ + ++/ +module wit.pumpkin.plugin.plugin; + +import wit.common; + +public import wit.pumpkin.plugin.logging.imports; +public import wit.pumpkin.plugin.common.imports; +public import wit.pumpkin.plugin.text.imports; +public import wit.pumpkin.plugin.attributes.imports; +public import wit.pumpkin.plugin.data_components.imports; +public import wit.pumpkin.plugin.enchantments.imports; +public import wit.pumpkin.plugin.item_stack.imports; +public import wit.pumpkin.plugin.screens.imports; +public import wit.pumpkin.plugin.inventory.imports; +public import wit.pumpkin.plugin.gui.imports; +public import wit.pumpkin.plugin.scoreboard.imports; +public import wit.pumpkin.plugin.block_entity.imports; +public import wit.pumpkin.plugin.particles.imports; +public import wit.pumpkin.plugin.sounds.imports; +public import wit.pumpkin.plugin.entity_types.imports; +public import wit.pumpkin.plugin.biomes.imports; +public import wit.pumpkin.plugin.damage_types.imports; +public import wit.pumpkin.plugin.game_rules.imports; +public import wit.pumpkin.plugin.uuid.imports; +public import wit.pumpkin.plugin.world.imports; +public import wit.pumpkin.plugin.permission.imports; +public import wit.pumpkin.plugin.forms.imports; +public import wit.pumpkin.plugin.java_dialogs.imports; +public import wit.pumpkin.plugin.java_packets.imports; +public import wit.pumpkin.plugin.bedrock_packets.imports; +public import wit.pumpkin.plugin.status_effect.imports; +public import wit.pumpkin.plugin.advancement.imports; +public import wit.pumpkin.plugin.statistics.imports; +public import wit.pumpkin.plugin.entity_statuses.imports; +public import wit.pumpkin.plugin.player.imports; +public import wit.pumpkin.plugin.recipe.imports; +public import wit.pumpkin.plugin.datapack.imports; +public import wit.pumpkin.plugin.server.imports; +public import wit.pumpkin.plugin.command.imports; +public import wit.pumpkin.plugin.event.imports; +public import wit.pumpkin.plugin.context.imports; +public import wit.pumpkin.plugin.i18n.imports; +public import wit.pumpkin.plugin.scheduler.imports; +public import wit.pumpkin.plugin.entity.imports; +public import wit.pumpkin.plugin.boss_bar.imports; +public import wit.pumpkin.plugin.ipc.imports; +public import wit.pumpkin.plugin.display.imports; +public import wit.pumpkin.plugin.game_events.imports; +public import wit.pumpkin.plugin.potions.imports; +public import wit.pumpkin.plugin.metadata.exports; + +/++ + ++/ +alias Context = wit.pumpkin.plugin.context.imports.Context; + +/++ + ++/ +alias Event = wit.pumpkin.plugin.event.imports.Event; + +/++ + ++/ +alias ServerInstance = wit.pumpkin.plugin.server.imports.Server; + +/++ + ++/ +alias CommandSender = wit.pumpkin.plugin.command.imports.CommandSender; + +/++ + ++/ +alias ConsumedArgs = wit.pumpkin.plugin.command.imports.ConsumedArgs; + +/++ + ++/ +alias CommandError = wit.pumpkin.plugin.command.imports.CommandError; + +/++ + ++/ +alias CommandSuggestions = wit.pumpkin.plugin.command.imports.CommandSuggestions; + +/++ + ++/ +alias SuggestionRequest = wit.pumpkin.plugin.command.imports.SuggestionRequest; + +/++ + ++/ +alias Entity = wit.pumpkin.plugin.world.imports.Entity; + +/++ + ++/ +alias ChunkBuffer = wit.pumpkin.plugin.world.imports.ChunkBuffer; + +/++ + ++/ +alias GenerationPhase = wit.pumpkin.plugin.world.imports.GenerationPhase; + +/++ + ++/ +alias PluginId = wit.pumpkin.plugin.ipc.imports.PluginId; + +/++ + ++/ +alias IpcMessage = wit.pumpkin.plugin.ipc.imports.IpcMessage; + + +private alias AliasSeq(T...) = T; +template Exports(Impl...) { + + alias FilteredImpl = wit.common.findWitExports!Impl; + alias InterfaceExports = AliasSeq!( + wit.pumpkin.plugin.metadata.exports.Exports!FilteredImpl + ); + + /++ + --- Plugin-provided exports --- + Called by the host once to initialize the plugin. + Internal use only; plugins should use the `register_plugin!` macro. + +/ + alias initPlugin_Sig = void function(); + /// ditto + alias initPlugin_Impl = findWitExportFunc!("$root", "init-plugin", initPlugin_Sig, Impl); + /// ditto + @wasmExport!("init-plugin") + pragma(mangle, "__wit_export_init_plugin") + private extern(C) void __export_initPlugin() { + initPlugin_Impl(); + } + + /++ + Called when the plugin is being loaded. + Use this to register commands, events, and perform initial setup. + +/ + alias onLoad_Sig = Result!(void, WitString) function(Context context); + /// ditto + alias onLoad_Impl = findWitExportFunc!("$root", "on-load", onLoad_Sig, Impl); + /// ditto + @wasmExport!("on-load") + pragma(mangle, "__wit_export_on_load") + private extern(C) void* __export_onLoad(uint arg0) { + alias _retArea = _exportsRetArea; + auto _handle0 = Context(arg0); + auto _ret = onLoad_Impl(_handle0); + if (_ret.isErr) { + ref _payload4 = _ret.unwrapErr(); + *cast(ubyte*)(_retArea.ptr + 0) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (2*size_t.sizeof)) = cast(size_t)(_payload4.length); + *cast(void**)(_retArea.ptr + size_t.sizeof) = cast(void*)(cast(void*)(_payload4.ptr)); + } else { + + *cast(ubyte*)(_retArea.ptr + 0) = cast(ubyte)(0); + } + return _retArea.ptr; + } + @wasmExport!("cabi_post_on-load") + pragma(mangle, "__wit_cabi_post_on_load") + private extern(C) void __cabi_post_onLoad(void* arg0) { + switch (cast(uint)(*(cast(ubyte*)(arg0 + 0)))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + size_t.sizeof))); + } + break; + } + default: break; + } + } + + /++ + Called when the plugin is being unloaded. + Use this to save data and clean up resources. + +/ + alias onUnload_Sig = Result!(void, WitString) function(Context context); + /// ditto + alias onUnload_Impl = findWitExportFunc!("$root", "on-unload", onUnload_Sig, Impl); + /// ditto + @wasmExport!("on-unload") + pragma(mangle, "__wit_export_on_unload") + private extern(C) void* __export_onUnload(uint arg0) { + alias _retArea = _exportsRetArea; + auto _handle0 = Context(arg0); + auto _ret = onUnload_Impl(_handle0); + if (_ret.isErr) { + ref _payload4 = _ret.unwrapErr(); + *cast(ubyte*)(_retArea.ptr + 0) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (2*size_t.sizeof)) = cast(size_t)(_payload4.length); + *cast(void**)(_retArea.ptr + size_t.sizeof) = cast(void*)(cast(void*)(_payload4.ptr)); + } else { + + *cast(ubyte*)(_retArea.ptr + 0) = cast(ubyte)(0); + } + return _retArea.ptr; + } + @wasmExport!("cabi_post_on-unload") + pragma(mangle, "__wit_cabi_post_on_unload") + private extern(C) void __cabi_post_onUnload(void* arg0) { + switch (cast(uint)(*(cast(ubyte*)(arg0 + 0)))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + size_t.sizeof))); + } + break; + } + default: break; + } + } + + /++ + Dispatches an event to the plugin for handling. + +/ + alias handleEvent_Sig = Event function(uint eventId, ServerInstance server, scope ref Event event); + /// ditto + alias handleEvent_Impl = findWitExportFunc!("$root", "handle-event", handleEvent_Sig, Impl); + /// ditto + @wasmExport!("handle-event") + pragma(mangle, "__wit_export_handle_event") + private extern(C) void* __export_handleEvent(void* arg0) { + alias _retArea = _exportsRetArea; + wit.common.DeallocateBuffer deallocate; + auto _handle0 = ServerInstance(*(cast(uint*)(arg0 + 4))); + wit.pumpkin.plugin.event.imports.Event _variant4520 = void; + auto _tag4520 = cast(uint)(*(cast(ushort*)(arg0 + 8))); + alias _Tag4520 = wit.pumpkin.plugin.event.imports.Event.Tag; + final switch (cast(wit.pumpkin.plugin.event.imports.Event.Tag)_tag4520) { + case _Tag4520.playerJoinEvent: { + auto _handle2 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _handle3 = wit.pumpkin.plugin.event.imports.TextComponent(*(cast(uint*)(arg0 + 20))); + wit.pumpkin.plugin.event.imports.PlayerJoinEventData _record4 = { + player: _handle2, + joinMessage: _handle3, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4521 = _record4; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerJoinEvent(_payload4521); + break; + } + case _Tag4520.playerLeaveEvent: { + auto _handle6 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _handle7 = wit.pumpkin.plugin.event.imports.TextComponent(*(cast(uint*)(arg0 + 20))); + wit.pumpkin.plugin.event.imports.PlayerLeaveEventData _record8 = { + player: _handle6, + leaveMessage: _handle7, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4522 = _record8; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerLeaveEvent(_payload4522); + break; + } + case _Tag4520.playerLoginEvent: { + auto _handle10 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _handle11 = wit.pumpkin.plugin.event.imports.TextComponent(*(cast(uint*)(arg0 + 20))); + wit.pumpkin.plugin.event.imports.PlayerLoginEventData _record12 = { + player: _handle10, + kickMessage: _handle11, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4523 = _record12; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerLoginEvent(_payload4523); + break; + } + case _Tag4520.playerChatEvent: { + auto _handle14 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len15 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr15 = _len15 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len15) deallocate ~= cast()_ptr15; + auto _list16 = WitString(_ptr15[0.._len15]); + auto _len17 = *(cast(size_t*)(arg0 + (16+4*size_t.sizeof))); + auto _ptr17 = _len17 ? cast(wit.pumpkin.plugin.event.imports.Player*)(*(cast(void**)(arg0 + (16+3*size_t.sizeof)))) : null; + if (_len17) deallocate ~= cast()_ptr17; + auto _list18 = WitList!(wit.pumpkin.plugin.event.imports.Player)(_ptr17[0.._len17]); + Option!(WitList!(ubyte)) _option23 = void; + bool _isSome23 = (cast(uint)(*(cast(ubyte*)(arg0 + (16+5*size_t.sizeof))))) != 0; + if (_isSome23) { + auto _len21 = *(cast(size_t*)(arg0 + (16+7*size_t.sizeof))); + auto _ptr21 = _len21 ? cast(ubyte*)(*(cast(void**)(arg0 + (16+6*size_t.sizeof)))) : null; + if (_len21) deallocate ~= cast()_ptr21; + auto _list22 = WitList!(ubyte)(_ptr21[0.._len21]); + + _option23 = Option!(WitList!(ubyte)).makeSome(_list22); + } else { + _option23 = Option!(WitList!(ubyte)).makeNone; + } + wit.pumpkin.plugin.event.imports.PlayerChatEventData _record24 = { + player: _handle14, + message: _list16, + recipients: _list18, + signature: _option23, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+8*size_t.sizeof))))) != 0, + }; + auto _payload4524 = _record24; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerChatEvent(_payload4524); + break; + } + case _Tag4520.playerCommandSendEvent: { + auto _handle26 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len27 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr27 = _len27 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len27) deallocate ~= cast()_ptr27; + auto _list28 = WitString(_ptr27[0.._len27]); + wit.pumpkin.plugin.event.imports.PlayerCommandSendEventData _record29 = { + player: _handle26, + command: _list28, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + }; + auto _payload4525 = _record29; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerCommandSendEvent(_payload4525); + break; + } + case _Tag4520.playerPermissionCheckEvent: { + auto _handle31 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len32 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr32 = _len32 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len32) deallocate ~= cast()_ptr32; + auto _list33 = WitString(_ptr32[0.._len32]); + wit.pumpkin.plugin.event.imports.PlayerPermissionCheckEventData _record34 = { + player: _handle31, + permission: _list33, + permissionResult: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + }; + auto _payload4526 = _record34; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerPermissionCheckEvent(_payload4526); + break; + } + case _Tag4520.playerMoveEvent: { + auto _handle36 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _tuple37 = wit.pumpkin.plugin.common.common.Position( + *(cast(double*)(arg0 + 24)), + *(cast(double*)(arg0 + 32)), + *(cast(double*)(arg0 + 40)), + ); + auto _tuple38 = wit.pumpkin.plugin.common.common.Position( + *(cast(double*)(arg0 + 48)), + *(cast(double*)(arg0 + 56)), + *(cast(double*)(arg0 + 64)), + ); + wit.pumpkin.plugin.event.imports.PlayerMoveEventData _record39 = { + player: _handle36, + fromPosition: _tuple37, + toPosition: _tuple38, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 72)))) != 0, + }; + auto _payload4527 = _record39; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerMoveEvent(_payload4527); + break; + } + case _Tag4520.playerTeleportEvent: { + auto _handle41 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _tuple42 = wit.pumpkin.plugin.common.common.Position( + *(cast(double*)(arg0 + 24)), + *(cast(double*)(arg0 + 32)), + *(cast(double*)(arg0 + 40)), + ); + auto _tuple43 = wit.pumpkin.plugin.common.common.Position( + *(cast(double*)(arg0 + 48)), + *(cast(double*)(arg0 + 56)), + *(cast(double*)(arg0 + 64)), + ); + wit.pumpkin.plugin.event.imports.PlayerTeleportEventData _record44 = { + player: _handle41, + fromPosition: _tuple42, + toPosition: _tuple43, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 72)))) != 0, + }; + auto _payload4528 = _record44; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerTeleportEvent(_payload4528); + break; + } + case _Tag4520.playerChangeWorldEvent: { + auto _handle46 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _handle47 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 20))); + auto _handle48 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 24))); + auto _tuple49 = wit.pumpkin.plugin.common.common.Position( + *(cast(double*)(arg0 + 32)), + *(cast(double*)(arg0 + 40)), + *(cast(double*)(arg0 + 48)), + ); + wit.pumpkin.plugin.event.imports.PlayerChangeWorldEventData _record50 = { + player: _handle46, + previousWorld: _handle47, + newWorld: _handle48, + position: _tuple49, + yaw: *(cast(float*)(arg0 + 56)), + pitch: *(cast(float*)(arg0 + 60)), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 64)))) != 0, + }; + auto _payload4529 = _record50; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerChangeWorldEvent(_payload4529); + break; + } + case _Tag4520.playerRespawnEvent: { + auto _handle52 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _handle53 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 20))); + auto _handle54 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 24))); + auto _tuple55 = wit.pumpkin.plugin.common.common.Position( + *(cast(double*)(arg0 + 32)), + *(cast(double*)(arg0 + 40)), + *(cast(double*)(arg0 + 48)), + ); + wit.pumpkin.plugin.event.imports.PlayerRespawnEventData _record56 = { + player: _handle52, + previousWorld: _handle53, + respawnedWorld: _handle54, + position: _tuple55, + yaw: *(cast(float*)(arg0 + 56)), + pitch: *(cast(float*)(arg0 + 60)), + alive: (cast(uint)(*(cast(ubyte*)(arg0 + 64)))) != 0, + }; + auto _payload4530 = _record56; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerRespawnEvent(_payload4530); + break; + } + case _Tag4520.playerExpChangeEvent: { + auto _handle58 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.PlayerExpChangeEventData _record59 = { + player: _handle58, + amount: cast(int)(*(cast(uint*)(arg0 + 20))), + }; + auto _payload4531 = _record59; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerExpChangeEvent(_payload4531); + break; + } + case _Tag4520.playerItemHeldEvent: { + auto _handle61 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.PlayerItemHeldEventData _record62 = { + player: _handle61, + previousSlot: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 20)))), + newSlot: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 21)))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 22)))) != 0, + }; + auto _payload4532 = _record62; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerItemHeldEvent(_payload4532); + break; + } + case _Tag4520.playerChangedMainHandEvent: { + auto _handle64 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.PlayerChangedMainHandEventData _record65 = { + player: _handle64, + mainHand: cast(wit.pumpkin.plugin.common.common.Hand)(cast(uint)(*(cast(ubyte*)(arg0 + 20)))), + }; + auto _payload4533 = _record65; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerChangedMainHandEvent(_payload4533); + break; + } + case _Tag4520.playerGamemodeChangeEvent: { + auto _handle67 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.PlayerGamemodeChangeEventData _record68 = { + player: _handle67, + previousGamemode: cast(wit.pumpkin.plugin.common.common.GameMode)(cast(uint)(*(cast(ubyte*)(arg0 + 20)))), + newGamemode: cast(wit.pumpkin.plugin.common.common.GameMode)(cast(uint)(*(cast(ubyte*)(arg0 + 21)))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 22)))) != 0, + }; + auto _payload4534 = _record68; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerGamemodeChangeEvent(_payload4534); + break; + } + case _Tag4520.playerCustomPayloadEvent: { + auto _handle70 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len71 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr71 = _len71 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len71) deallocate ~= cast()_ptr71; + auto _list72 = WitString(_ptr71[0.._len71]); + auto _len73 = *(cast(size_t*)(arg0 + (16+4*size_t.sizeof))); + auto _ptr73 = _len73 ? cast(ubyte*)(*(cast(void**)(arg0 + (16+3*size_t.sizeof)))) : null; + if (_len73) deallocate ~= cast()_ptr73; + auto _list74 = WitList!(ubyte)(_ptr73[0.._len73]); + wit.pumpkin.plugin.event.imports.PlayerCustomPayloadEventData _record75 = { + player: _handle70, + channel: _list72, + data: _list74, + }; + auto _payload4535 = _record75; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerCustomPayloadEvent(_payload4535); + break; + } + case _Tag4520.playerFishEvent: { + auto _handle77 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + Option!(wit.pumpkin.plugin.event.common.Uuid) _option81 = void; + bool _isSome81 = (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0; + if (_isSome81) { + wit.pumpkin.plugin.uuid.common.Uuid _record80 = { + high: *(cast(ulong*)(arg0 + 32)), + low: *(cast(ulong*)(arg0 + 40)), + }; + + _option81 = Option!(wit.pumpkin.plugin.event.common.Uuid).makeSome(_record80); + } else { + _option81 = Option!(wit.pumpkin.plugin.event.common.Uuid).makeNone; + } + auto _len82 = *(cast(size_t*)(arg0 + (48+1*size_t.sizeof))); + auto _ptr82 = _len82 ? cast(char*)(*(cast(void**)(arg0 + 48))) : null; + if (_len82) deallocate ~= cast()_ptr82; + auto _list83 = WitString(_ptr82[0.._len82]); + wit.pumpkin.plugin.uuid.common.Uuid _record84 = { + high: *(cast(ulong*)(arg0 + (48+2*size_t.sizeof))), + low: *(cast(ulong*)(arg0 + (56+2*size_t.sizeof))), + }; + wit.pumpkin.plugin.event.imports.PlayerFishEventData _record85 = { + player: _handle77, + caughtUuid: _option81, + caughtType: _list83, + hookUuid: _record84, + state: cast(wit.pumpkin.plugin.event.common.PlayerFishState)(cast(uint)(*(cast(ubyte*)(arg0 + (64+2*size_t.sizeof))))), + hand: cast(wit.pumpkin.plugin.common.common.Hand)(cast(uint)(*(cast(ubyte*)(arg0 + (65+2*size_t.sizeof))))), + expToDrop: cast(int)(*(cast(uint*)(arg0 + (68+2*size_t.sizeof)))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (72+2*size_t.sizeof))))) != 0, + }; + auto _payload4536 = _record85; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerFishEvent(_payload4536); + break; + } + case _Tag4520.playerEggThrowEvent: { + auto _handle87 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.uuid.common.Uuid _record88 = { + high: *(cast(ulong*)(arg0 + 24)), + low: *(cast(ulong*)(arg0 + 32)), + }; + auto _len89 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _ptr89 = _len89 ? cast(char*)(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))) : null; + if (_len89) deallocate ~= cast()_ptr89; + auto _list90 = WitString(_ptr89[0.._len89]); + wit.pumpkin.plugin.event.imports.PlayerEggThrowEventData _record91 = { + player: _handle87, + eggUuid: _record88, + hatching: (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0, + numHatches: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 41)))), + hatchingType: _list90, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (40+3*size_t.sizeof))))) != 0, + }; + auto _payload4537 = _record91; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerEggThrowEvent(_payload4537); + break; + } + case _Tag4520.playerInteractUnknownEntityEvent: { + auto _handle93 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.PlayerInteractUnknownEntityEventData _record94 = { + player: _handle93, + entityId: cast(int)(*(cast(uint*)(arg0 + 20))), + action: cast(wit.pumpkin.plugin.event.common.EntityInteractionAction)(cast(uint)(*(cast(ubyte*)(arg0 + 24)))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 25)))) != 0, + }; + auto _payload4538 = _record94; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerInteractUnknownEntityEvent(_payload4538); + break; + } + case _Tag4520.playerInteractEntityEvent: { + auto _handle96 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.PlayerInteractEntityEventData _record97 = { + player: _handle96, + entityId: cast(int)(*(cast(uint*)(arg0 + 20))), + action: cast(wit.pumpkin.plugin.event.common.EntityInteractionAction)(cast(uint)(*(cast(ubyte*)(arg0 + 24)))), + sneaking: (cast(uint)(*(cast(ubyte*)(arg0 + 25)))) != 0, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 26)))) != 0, + }; + auto _payload4539 = _record97; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerInteractEntityEvent(_payload4539); + break; + } + case _Tag4520.playerInteractEvent: { + auto _handle99 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + Option!(wit.pumpkin.plugin.event.common.BlockPos) _option103 = void; + bool _isSome103 = (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0; + if (_isSome103) { + wit.pumpkin.plugin.common.common.BlockPos _record102 = { + x: cast(int)(*(cast(uint*)(arg0 + 28))), + y: cast(int)(*(cast(uint*)(arg0 + 32))), + z: cast(int)(*(cast(uint*)(arg0 + 36))), + }; + + _option103 = Option!(wit.pumpkin.plugin.event.common.BlockPos).makeSome(_record102); + } else { + _option103 = Option!(wit.pumpkin.plugin.event.common.BlockPos).makeNone; + } + auto _len104 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr104 = _len104 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len104) deallocate ~= cast()_ptr104; + auto _list105 = WitString(_ptr104[0.._len104]); + wit.pumpkin.plugin.event.imports.PlayerInteractEventData _record106 = { + player: _handle99, + action: cast(wit.pumpkin.plugin.event.common.InteractAction)(cast(uint)(*(cast(ubyte*)(arg0 + 20)))), + clickedPos: _option103, + block: _list105, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (40+2*size_t.sizeof))))) != 0, + }; + auto _payload4540 = _record106; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerInteractEvent(_payload4540); + break; + } + case _Tag4520.playerToggleSneakEvent: { + auto _handle108 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.PlayerToggleSneakEventData _record109 = { + player: _handle108, + isSneaking: (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 21)))) != 0, + }; + auto _payload4541 = _record109; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerToggleSneakEvent(_payload4541); + break; + } + case _Tag4520.playerToggleFlightEvent: { + auto _handle111 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.PlayerToggleFlightEventData _record112 = { + player: _handle111, + isFlying: (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 21)))) != 0, + }; + auto _payload4542 = _record112; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerToggleFlightEvent(_payload4542); + break; + } + case _Tag4520.playerToggleSprintEvent: { + auto _handle114 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.PlayerToggleSprintEventData _record115 = { + player: _handle114, + isSprinting: (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 21)))) != 0, + }; + auto _payload4543 = _record115; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerToggleSprintEvent(_payload4543); + break; + } + case _Tag4520.inventoryClickEvent: { + auto _handle117 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + Option!(wit.pumpkin.plugin.event.common.Screen) _option120 = void; + bool _isSome120 = (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0; + if (_isSome120) { + + _option120 = Option!(wit.pumpkin.plugin.event.common.Screen).makeSome(cast(wit.pumpkin.plugin.screens.common.Screen)(cast(uint)(*(cast(ubyte*)(arg0 + 21))))); + } else { + _option120 = Option!(wit.pumpkin.plugin.event.common.Screen).makeNone; + } + Option!(wit.pumpkin.plugin.event.imports.ItemStack) _option124 = void; + bool _isSome124 = (cast(uint)(*(cast(ubyte*)(arg0 + 28)))) != 0; + if (_isSome124) { + auto _handle123 = wit.pumpkin.plugin.event.imports.ItemStack(*(cast(uint*)(arg0 + 32))); + + _option124 = Option!(wit.pumpkin.plugin.event.imports.ItemStack).makeSome(_handle123); + } else { + _option124 = Option!(wit.pumpkin.plugin.event.imports.ItemStack).makeNone; + } + Option!(wit.pumpkin.plugin.event.imports.ItemStack) _option128 = void; + bool _isSome128 = (cast(uint)(*(cast(ubyte*)(arg0 + 36)))) != 0; + if (_isSome128) { + auto _handle127 = wit.pumpkin.plugin.event.imports.ItemStack(*(cast(uint*)(arg0 + 40))); + + _option128 = Option!(wit.pumpkin.plugin.event.imports.ItemStack).makeSome(_handle127); + } else { + _option128 = Option!(wit.pumpkin.plugin.event.imports.ItemStack).makeNone; + } + wit.pumpkin.plugin.event.imports.InventoryClickEventData _record129 = { + player: _handle117, + windowType: _option120, + clickType: cast(wit.pumpkin.plugin.common.common.ClickType)(cast(uint)(*(cast(ubyte*)(arg0 + 22)))), + slot: cast(short)(cast(uint)(*(cast(short*)(arg0 + 24)))), + rawSlot: cast(short)(cast(uint)(*(cast(short*)(arg0 + 26)))), + clickedItem: _option124, + cursor: _option128, + hotbarButton: cast(int)(*(cast(uint*)(arg0 + 44))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 48)))) != 0, + }; + auto _payload4544 = _record129; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.inventoryClickEvent(_payload4544); + break; + } + case _Tag4520.inventoryCloseEvent: { + auto _handle131 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + Option!(wit.pumpkin.plugin.event.common.Screen) _option134 = void; + bool _isSome134 = (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0; + if (_isSome134) { + + _option134 = Option!(wit.pumpkin.plugin.event.common.Screen).makeSome(cast(wit.pumpkin.plugin.screens.common.Screen)(cast(uint)(*(cast(ubyte*)(arg0 + 21))))); + } else { + _option134 = Option!(wit.pumpkin.plugin.event.common.Screen).makeNone; + } + wit.pumpkin.plugin.event.imports.InventoryCloseEventData _record135 = { + player: _handle131, + windowType: _option134, + }; + auto _payload4545 = _record135; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.inventoryCloseEvent(_payload4545); + break; + } + case _Tag4520.blockRedstoneEvent: { + auto _handle137 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.common.common.BlockPos _record138 = { + x: cast(int)(*(cast(uint*)(arg0 + 24))), + y: cast(int)(*(cast(uint*)(arg0 + 28))), + z: cast(int)(*(cast(uint*)(arg0 + 32))), + }; + wit.pumpkin.plugin.event.imports.BlockRedstoneEventData _record139 = { + targetWorld: _handle137, + stateId: cast(ushort)(cast(uint)(*(cast(ushort*)(arg0 + 20)))), + blockPos: _record138, + oldCurrent: cast(int)(*(cast(uint*)(arg0 + 36))), + newCurrent: cast(int)(*(cast(uint*)(arg0 + 40))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 44)))) != 0, + }; + auto _payload4546 = _record139; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockRedstoneEvent(_payload4546); + break; + } + case _Tag4520.blockBreakEvent: { + Option!(wit.pumpkin.plugin.event.imports.Player) _option144 = void; + bool _isSome144 = (cast(uint)(*(cast(ubyte*)(arg0 + 16)))) != 0; + if (_isSome144) { + auto _handle143 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 20))); + + _option144 = Option!(wit.pumpkin.plugin.event.imports.Player).makeSome(_handle143); + } else { + _option144 = Option!(wit.pumpkin.plugin.event.imports.Player).makeNone; + } + auto _len145 = *(cast(size_t*)(arg0 + (24+1*size_t.sizeof))); + auto _ptr145 = _len145 ? cast(char*)(*(cast(void**)(arg0 + 24))) : null; + if (_len145) deallocate ~= cast()_ptr145; + auto _list146 = WitString(_ptr145[0.._len145]); + wit.pumpkin.plugin.common.common.BlockPos _record147 = { + x: cast(int)(*(cast(uint*)(arg0 + (24+2*size_t.sizeof)))), + y: cast(int)(*(cast(uint*)(arg0 + (28+2*size_t.sizeof)))), + z: cast(int)(*(cast(uint*)(arg0 + (32+2*size_t.sizeof)))), + }; + wit.pumpkin.plugin.event.imports.BlockBreakEventData _record148 = { + player: _option144, + block: _list146, + blockPos: _record147, + exp: *(cast(uint*)(arg0 + (36+2*size_t.sizeof))), + shouldDrop: (cast(uint)(*(cast(ubyte*)(arg0 + (40+2*size_t.sizeof))))) != 0, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (41+2*size_t.sizeof))))) != 0, + }; + auto _payload4547 = _record148; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockBreakEvent(_payload4547); + break; + } + case _Tag4520.blockBurnEvent: { + auto _len150 = *(cast(size_t*)(arg0 + (16+1*size_t.sizeof))); + auto _ptr150 = _len150 ? cast(char*)(*(cast(void**)(arg0 + 16))) : null; + if (_len150) deallocate ~= cast()_ptr150; + auto _list151 = WitString(_ptr150[0.._len150]); + auto _len152 = *(cast(size_t*)(arg0 + (16+3*size_t.sizeof))); + auto _ptr152 = _len152 ? cast(char*)(*(cast(void**)(arg0 + (16+2*size_t.sizeof)))) : null; + if (_len152) deallocate ~= cast()_ptr152; + auto _list153 = WitString(_ptr152[0.._len152]); + wit.pumpkin.plugin.event.common.BlockBurnEventData _record154 = { + ignitingBlock: _list151, + block: _list153, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+4*size_t.sizeof))))) != 0, + }; + auto _payload4548 = _record154; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockBurnEvent(_payload4548); + break; + } + case _Tag4520.blockCanBuildEvent: { + auto _len156 = *(cast(size_t*)(arg0 + (16+1*size_t.sizeof))); + auto _ptr156 = _len156 ? cast(char*)(*(cast(void**)(arg0 + 16))) : null; + if (_len156) deallocate ~= cast()_ptr156; + auto _list157 = WitString(_ptr156[0.._len156]); + auto _handle158 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + (20+2*size_t.sizeof)))); + auto _len159 = *(cast(size_t*)(arg0 + (24+3*size_t.sizeof))); + auto _ptr159 = _len159 ? cast(char*)(*(cast(void**)(arg0 + (24+2*size_t.sizeof)))) : null; + if (_len159) deallocate ~= cast()_ptr159; + auto _list160 = WitString(_ptr159[0.._len159]); + wit.pumpkin.plugin.event.imports.BlockCanBuildEventData _record161 = { + blockToBuild: _list157, + buildable: (cast(uint)(*(cast(ubyte*)(arg0 + (16+2*size_t.sizeof))))) != 0, + player: _handle158, + block: _list160, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (24+4*size_t.sizeof))))) != 0, + }; + auto _payload4549 = _record161; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockCanBuildEvent(_payload4549); + break; + } + case _Tag4520.blockGrowEvent: { + auto _handle163 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 16))); + auto _len164 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr164 = _len164 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len164) deallocate ~= cast()_ptr164; + auto _list165 = WitString(_ptr164[0.._len164]); + auto _len166 = *(cast(size_t*)(arg0 + (16+5*size_t.sizeof))); + auto _ptr166 = _len166 ? cast(char*)(*(cast(void**)(arg0 + (16+4*size_t.sizeof)))) : null; + if (_len166) deallocate ~= cast()_ptr166; + auto _list167 = WitString(_ptr166[0.._len166]); + wit.pumpkin.plugin.common.common.BlockPos _record168 = { + x: cast(int)(*(cast(uint*)(arg0 + (20+6*size_t.sizeof)))), + y: cast(int)(*(cast(uint*)(arg0 + (24+6*size_t.sizeof)))), + z: cast(int)(*(cast(uint*)(arg0 + (28+6*size_t.sizeof)))), + }; + wit.pumpkin.plugin.event.imports.BlockGrowEventData _record169 = { + targetWorld: _handle163, + oldBlock: _list165, + oldStateId: cast(ushort)(cast(uint)(*(cast(ushort*)(arg0 + (16+3*size_t.sizeof))))), + newBlock: _list167, + newStateId: cast(ushort)(cast(uint)(*(cast(ushort*)(arg0 + (16+6*size_t.sizeof))))), + blockPos: _record168, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (32+6*size_t.sizeof))))) != 0, + }; + auto _payload4550 = _record169; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockGrowEvent(_payload4550); + break; + } + case _Tag4520.blockPlaceEvent: { + auto _handle171 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len172 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr172 = _len172 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len172) deallocate ~= cast()_ptr172; + auto _list173 = WitString(_ptr172[0.._len172]); + auto _len174 = *(cast(size_t*)(arg0 + (16+4*size_t.sizeof))); + auto _ptr174 = _len174 ? cast(char*)(*(cast(void**)(arg0 + (16+3*size_t.sizeof)))) : null; + if (_len174) deallocate ~= cast()_ptr174; + auto _list175 = WitString(_ptr174[0.._len174]); + wit.pumpkin.plugin.common.common.BlockPos _record176 = { + x: cast(int)(*(cast(uint*)(arg0 + (16+5*size_t.sizeof)))), + y: cast(int)(*(cast(uint*)(arg0 + (20+5*size_t.sizeof)))), + z: cast(int)(*(cast(uint*)(arg0 + (24+5*size_t.sizeof)))), + }; + wit.pumpkin.plugin.event.imports.BlockPlaceEventData _record177 = { + player: _handle171, + blockPlaced: _list173, + blockPlacedAgainst: _list175, + blockPos: _record176, + canBuild: (cast(uint)(*(cast(ubyte*)(arg0 + (28+5*size_t.sizeof))))) != 0, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (29+5*size_t.sizeof))))) != 0, + }; + auto _payload4551 = _record177; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockPlaceEvent(_payload4551); + break; + } + case _Tag4520.dialogClickActionEvent: { + auto _handle179 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len180 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr180 = _len180 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len180) deallocate ~= cast()_ptr180; + auto _list181 = WitString(_ptr180[0.._len180]); + Option!(WitList!(ubyte)) _option186 = void; + bool _isSome186 = (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0; + if (_isSome186) { + auto _len184 = *(cast(size_t*)(arg0 + (16+5*size_t.sizeof))); + auto _ptr184 = _len184 ? cast(ubyte*)(*(cast(void**)(arg0 + (16+4*size_t.sizeof)))) : null; + if (_len184) deallocate ~= cast()_ptr184; + auto _list185 = WitList!(ubyte)(_ptr184[0.._len184]); + + _option186 = Option!(WitList!(ubyte)).makeSome(_list185); + } else { + _option186 = Option!(WitList!(ubyte)).makeNone; + } + wit.pumpkin.plugin.event.imports.DialogClickActionEventData _record187 = { + player: _handle179, + id: _list181, + payload: _option186, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+6*size_t.sizeof))))) != 0, + }; + auto _payload4552 = _record187; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.dialogClickActionEvent(_payload4552); + break; + } + case _Tag4520.dialogShowEvent: { + auto _handle189 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _handle190 = wit.pumpkin.plugin.java_dialogs.imports.TextComponent(*(cast(uint*)(arg0 + (16+1*size_t.sizeof)))); + auto _listSrcPtr199 = *(cast(void**)(arg0 + (24+1*size_t.sizeof))); + auto _listLen199 = *(cast(size_t*)(arg0 + (24+2*size_t.sizeof))); + auto _list199 = _listLen199 ? wit.common.mallocSlice!(wit.pumpkin.plugin.java_dialogs.imports.DialogBody)(_listLen199) : []; + assert(!_listLen199 || _list199.ptr); + if (_listLen199) deallocate ~= cast(void*)_list199.ptr; + foreach (_elem191_idx, ref _elem191; _list199) { + const auto _base191 = _listSrcPtr199 + _elem191_idx * 8; + wit.pumpkin.plugin.java_dialogs.imports.DialogBody _variant196 = void; + auto _tag196 = cast(uint)(*(cast(ubyte*)(_base191 + 0))); + alias _Tag196 = wit.pumpkin.plugin.java_dialogs.imports.DialogBody.Tag; + final switch (cast(wit.pumpkin.plugin.java_dialogs.imports.DialogBody.Tag)_tag196) { + case _Tag196.plainMessage: { + auto _handle193 = wit.pumpkin.plugin.java_dialogs.imports.TextComponent(*(cast(uint*)(_base191 + 4))); + auto _payload197 = _handle193; + _variant196 = wit.pumpkin.plugin.java_dialogs.imports.DialogBody.plainMessage(_payload197); + break; + } + case _Tag196.item: { + auto _handle195 = wit.pumpkin.plugin.java_dialogs.imports.ItemStack(*(cast(uint*)(_base191 + 4))); + auto _payload198 = _handle195; + _variant196 = wit.pumpkin.plugin.java_dialogs.imports.DialogBody.item(_payload198); + break; + } + } + _elem191 = _variant196; + } + if (_listLen199) deallocate ~= _listSrcPtr199; + auto _witList200 = WitList!(wit.pumpkin.plugin.java_dialogs.imports.DialogBody)(_list199); + auto _listSrcPtr229 = *(cast(void**)(arg0 + (24+3*size_t.sizeof))); + auto _listLen229 = *(cast(size_t*)(arg0 + (24+4*size_t.sizeof))); + auto _list229 = _listLen229 ? wit.common.mallocSlice!(wit.pumpkin.plugin.java_dialogs.imports.DialogInput)(_listLen229) : []; + assert(!_listLen229 || _list229.ptr); + if (_listLen229) deallocate ~= cast(void*)_list229.ptr; + foreach (_elem201_idx, ref _elem201; _list229) { + const auto _base201 = _listSrcPtr229 + _elem201_idx * (16+5*size_t.sizeof); + wit.pumpkin.plugin.java_dialogs.imports.DialogInput _variant224 = void; + auto _tag224 = cast(uint)(*(cast(ubyte*)(_base201 + 0))); + alias _Tag224 = wit.pumpkin.plugin.java_dialogs.imports.DialogInput.Tag; + final switch (cast(wit.pumpkin.plugin.java_dialogs.imports.DialogInput.Tag)_tag224) { + case _Tag224.bool_: { + auto _handle203 = wit.pumpkin.plugin.java_dialogs.imports.TextComponent(*(cast(uint*)(_base201 + size_t.sizeof))); + wit.pumpkin.plugin.java_dialogs.imports.DialogInputBool _record204 = { + label: _handle203, + defaultValue: (cast(uint)(*(cast(ubyte*)(_base201 + (4+1*size_t.sizeof))))) != 0, + }; + auto _payload225 = _record204; + _variant224 = wit.pumpkin.plugin.java_dialogs.imports.DialogInput.bool_(_payload225); + break; + } + case _Tag224.text: { + auto _handle206 = wit.pumpkin.plugin.java_dialogs.imports.TextComponent(*(cast(uint*)(_base201 + size_t.sizeof))); + auto _handle207 = wit.pumpkin.plugin.java_dialogs.imports.TextComponent(*(cast(uint*)(_base201 + (4+1*size_t.sizeof)))); + auto _len208 = *(cast(size_t*)(_base201 + (8+2*size_t.sizeof))); + auto _ptr208 = _len208 ? cast(char*)(*(cast(void**)(_base201 + (8+1*size_t.sizeof)))) : null; + if (_len208) deallocate ~= cast()_ptr208; + auto _list209 = WitString(_ptr208[0.._len208]); + wit.pumpkin.plugin.java_dialogs.imports.DialogInputText _record210 = { + label: _handle206, + placeholder: _handle207, + defaultValue: _list209, + }; + auto _payload226 = _record210; + _variant224 = wit.pumpkin.plugin.java_dialogs.imports.DialogInput.text(_payload226); + break; + } + case _Tag224.numberRange: { + auto _handle212 = wit.pumpkin.plugin.java_dialogs.imports.TextComponent(*(cast(uint*)(_base201 + size_t.sizeof))); + Option!(WitString) _option217 = void; + bool _isSome217 = (cast(uint)(*(cast(ubyte*)(_base201 + (16+2*size_t.sizeof))))) != 0; + if (_isSome217) { + auto _len215 = *(cast(size_t*)(_base201 + (16+4*size_t.sizeof))); + auto _ptr215 = _len215 ? cast(char*)(*(cast(void**)(_base201 + (16+3*size_t.sizeof)))) : null; + if (_len215) deallocate ~= cast()_ptr215; + auto _list216 = WitString(_ptr215[0.._len215]); + + _option217 = Option!(WitString).makeSome(_list216); + } else { + _option217 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.java_dialogs.imports.DialogInputNumberRange _record218 = { + label: _handle212, + minValue: *(cast(float*)(_base201 + (4+1*size_t.sizeof))), + maxValue: *(cast(float*)(_base201 + (8+1*size_t.sizeof))), + initialValue: *(cast(float*)(_base201 + (12+1*size_t.sizeof))), + step: *(cast(float*)(_base201 + (16+1*size_t.sizeof))), + labelFormat: _option217, + }; + auto _payload227 = _record218; + _variant224 = wit.pumpkin.plugin.java_dialogs.imports.DialogInput.numberRange(_payload227); + break; + } + case _Tag224.singleOption: { + auto _handle220 = wit.pumpkin.plugin.java_dialogs.imports.TextComponent(*(cast(uint*)(_base201 + size_t.sizeof))); + auto _len221 = *(cast(size_t*)(_base201 + (3*size_t.sizeof))); + auto _ptr221 = _len221 ? cast(wit.pumpkin.plugin.java_dialogs.imports.TextComponent*)(*(cast(void**)(_base201 + (2*size_t.sizeof)))) : null; + if (_len221) deallocate ~= cast()_ptr221; + auto _list222 = WitList!(wit.pumpkin.plugin.java_dialogs.imports.TextComponent)(_ptr221[0.._len221]); + wit.pumpkin.plugin.java_dialogs.imports.DialogInputSingleOption _record223 = { + label: _handle220, + options: _list222, + initialIndex: *(cast(uint*)(_base201 + (4*size_t.sizeof))), + }; + auto _payload228 = _record223; + _variant224 = wit.pumpkin.plugin.java_dialogs.imports.DialogInput.singleOption(_payload228); + break; + } + } + _elem201 = _variant224; + } + if (_listLen229) deallocate ~= _listSrcPtr229; + auto _witList230 = WitList!(wit.pumpkin.plugin.java_dialogs.imports.DialogInput)(_list229); + auto _listSrcPtr256 = *(cast(void**)(arg0 + (24+5*size_t.sizeof))); + auto _listLen256 = *(cast(size_t*)(arg0 + (24+6*size_t.sizeof))); + auto _list256 = _listLen256 ? wit.common.mallocSlice!(wit.pumpkin.plugin.java_dialogs.imports.ActionButton)(_listLen256) : []; + assert(!_listLen256 || _list256.ptr); + if (_listLen256) deallocate ~= cast(void*)_list256.ptr; + foreach (_elem231_idx, ref _elem231; _list256) { + const auto _base231 = _listSrcPtr256 + _elem231_idx * (16+7*size_t.sizeof); + auto _handle232 = wit.pumpkin.plugin.java_dialogs.imports.TextComponent(*(cast(uint*)(_base231 + 0))); + Option!(wit.pumpkin.plugin.java_dialogs.imports.TextComponent) _option236 = void; + bool _isSome236 = (cast(uint)(*(cast(ubyte*)(_base231 + 4)))) != 0; + if (_isSome236) { + auto _handle235 = wit.pumpkin.plugin.java_dialogs.imports.TextComponent(*(cast(uint*)(_base231 + 8))); + + _option236 = Option!(wit.pumpkin.plugin.java_dialogs.imports.TextComponent).makeSome(_handle235); + } else { + _option236 = Option!(wit.pumpkin.plugin.java_dialogs.imports.TextComponent).makeNone; + } + Option!(uint) _option239 = void; + bool _isSome239 = (cast(uint)(*(cast(ubyte*)(_base231 + 12)))) != 0; + if (_isSome239) { + + _option239 = Option!(uint).makeSome(*(cast(uint*)(_base231 + 16))); + } else { + _option239 = Option!(uint).makeNone; + } + wit.pumpkin.plugin.java_dialogs.common.Action _variant252 = void; + auto _tag252 = cast(uint)(*(cast(ubyte*)(_base231 + (16+1*size_t.sizeof)))); + alias _Tag252 = wit.pumpkin.plugin.java_dialogs.common.Action.Tag; + final switch (cast(wit.pumpkin.plugin.java_dialogs.common.Action.Tag)_tag252) { + case _Tag252.openUrl: { + auto _len241 = *(cast(size_t*)(_base231 + (16+3*size_t.sizeof))); + auto _ptr241 = _len241 ? cast(char*)(*(cast(void**)(_base231 + (16+2*size_t.sizeof)))) : null; + if (_len241) deallocate ~= cast()_ptr241; + auto _list242 = WitString(_ptr241[0.._len241]); + auto _payload253 = _list242; + _variant252 = wit.pumpkin.plugin.java_dialogs.common.Action.openUrl(_payload253); + break; + } + case _Tag252.customClick: { + auto _len244 = *(cast(size_t*)(_base231 + (16+3*size_t.sizeof))); + auto _ptr244 = _len244 ? cast(char*)(*(cast(void**)(_base231 + (16+2*size_t.sizeof)))) : null; + if (_len244) deallocate ~= cast()_ptr244; + auto _list245 = WitString(_ptr244[0.._len244]); + Option!(WitList!(ubyte)) _option250 = void; + bool _isSome250 = (cast(uint)(*(cast(ubyte*)(_base231 + (16+4*size_t.sizeof))))) != 0; + if (_isSome250) { + auto _len248 = *(cast(size_t*)(_base231 + (16+6*size_t.sizeof))); + auto _ptr248 = _len248 ? cast(ubyte*)(*(cast(void**)(_base231 + (16+5*size_t.sizeof)))) : null; + if (_len248) deallocate ~= cast()_ptr248; + auto _list249 = WitList!(ubyte)(_ptr248[0.._len248]); + + _option250 = Option!(WitList!(ubyte)).makeSome(_list249); + } else { + _option250 = Option!(WitList!(ubyte)).makeNone; + } + wit.pumpkin.plugin.java_dialogs.common.CustomClickAction _record251 = { + id: _list245, + payload: _option250, + }; + auto _payload254 = _record251; + _variant252 = wit.pumpkin.plugin.java_dialogs.common.Action.customClick(_payload254); + break; + } + } + wit.pumpkin.plugin.java_dialogs.imports.ActionButton _record255 = { + text: _handle232, + tooltip: _option236, + width: _option239, + action: _variant252, + }; + _elem231 = _record255; + } + if (_listLen256) deallocate ~= _listSrcPtr256; + auto _witList257 = WitList!(wit.pumpkin.plugin.java_dialogs.imports.ActionButton)(_list256); + auto _listSrcPtr268 = *(cast(void**)(arg0 + (24+7*size_t.sizeof))); + auto _listLen268 = *(cast(size_t*)(arg0 + (24+8*size_t.sizeof))); + auto _list268 = _listLen268 ? wit.common.mallocSlice!(wit.pumpkin.plugin.java_dialogs.imports.Link)(_listLen268) : []; + assert(!_listLen268 || _list268.ptr); + if (_listLen268) deallocate ~= cast(void*)_list268.ptr; + foreach (_elem258_idx, ref _elem258; _list268) { + const auto _base258 = _listSrcPtr268 + _elem258_idx * (8+2*size_t.sizeof); + wit.pumpkin.plugin.java_dialogs.imports.LinkLabel _variant262 = void; + auto _tag262 = cast(uint)(*(cast(ubyte*)(_base258 + 0))); + alias _Tag262 = wit.pumpkin.plugin.java_dialogs.imports.LinkLabel.Tag; + final switch (cast(wit.pumpkin.plugin.java_dialogs.imports.LinkLabel.Tag)_tag262) { + case _Tag262.builtIn: { + auto _payload263 = cast(wit.pumpkin.plugin.java_dialogs.common.LinkType)(cast(uint)(*(cast(ubyte*)(_base258 + 4)))); + _variant262 = wit.pumpkin.plugin.java_dialogs.imports.LinkLabel.builtIn(_payload263); + break; + } + case _Tag262.custom: { + auto _handle261 = wit.pumpkin.plugin.java_dialogs.imports.TextComponent(*(cast(uint*)(_base258 + 4))); + auto _payload264 = _handle261; + _variant262 = wit.pumpkin.plugin.java_dialogs.imports.LinkLabel.custom(_payload264); + break; + } + } + auto _len265 = *(cast(size_t*)(_base258 + (8+1*size_t.sizeof))); + auto _ptr265 = _len265 ? cast(char*)(*(cast(void**)(_base258 + 8))) : null; + if (_len265) deallocate ~= cast()_ptr265; + auto _list266 = WitString(_ptr265[0.._len265]); + wit.pumpkin.plugin.java_dialogs.imports.Link _record267 = { + label: _variant262, + url: _list266, + }; + _elem258 = _record267; + } + if (_listLen268) deallocate ~= _listSrcPtr268; + auto _witList269 = WitList!(wit.pumpkin.plugin.java_dialogs.imports.Link)(_list268); + Option!(wit.pumpkin.plugin.java_dialogs.common.AfterAction) _option272 = void; + bool _isSome272 = (cast(uint)(*(cast(ubyte*)(arg0 + (24+9*size_t.sizeof))))) != 0; + if (_isSome272) { + + _option272 = Option!(wit.pumpkin.plugin.java_dialogs.common.AfterAction).makeSome(cast(wit.pumpkin.plugin.java_dialogs.common.AfterAction)(cast(uint)(*(cast(ubyte*)(arg0 + (25+9*size_t.sizeof)))))); + } else { + _option272 = Option!(wit.pumpkin.plugin.java_dialogs.common.AfterAction).makeNone; + } + Option!(wit.pumpkin.plugin.java_dialogs.imports.TextComponent) _option276 = void; + bool _isSome276 = (cast(uint)(*(cast(ubyte*)(arg0 + (28+9*size_t.sizeof))))) != 0; + if (_isSome276) { + auto _handle275 = wit.pumpkin.plugin.java_dialogs.imports.TextComponent(*(cast(uint*)(arg0 + (32+9*size_t.sizeof)))); + + _option276 = Option!(wit.pumpkin.plugin.java_dialogs.imports.TextComponent).makeSome(_handle275); + } else { + _option276 = Option!(wit.pumpkin.plugin.java_dialogs.imports.TextComponent).makeNone; + } + wit.pumpkin.plugin.java_dialogs.imports.Dialog _record277 = { + title: _handle190, + type: cast(wit.pumpkin.plugin.java_dialogs.common.DialogType)(cast(uint)(*(cast(ubyte*)(arg0 + (20+1*size_t.sizeof))))), + body_: _witList200, + inputs: _witList230, + buttons: _witList257, + links: _witList269, + afterAction: _option272, + canCloseWithEscape: (cast(uint)(*(cast(ubyte*)(arg0 + (26+9*size_t.sizeof))))) != 0, + externalTitle: _option276, + }; + wit.pumpkin.plugin.event.imports.DialogShowEventData _record278 = { + player: _handle189, + dialog: _record277, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (32+10*size_t.sizeof))))) != 0, + }; + auto _payload4553 = _record278; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.dialogShowEvent(_payload4553); + break; + } + case _Tag4520.dialogClearEvent: { + auto _handle280 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.DialogClearEventData _record281 = { + player: _handle280, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0, + }; + auto _payload4554 = _record281; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.dialogClearEvent(_payload4554); + break; + } + case _Tag4520.bedrockFormResponseEvent: { + auto _handle283 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + Option!(WitString) _option288 = void; + bool _isSome288 = (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0; + if (_isSome288) { + auto _len286 = *(cast(size_t*)(arg0 + (24+2*size_t.sizeof))); + auto _ptr286 = _len286 ? cast(char*)(*(cast(void**)(arg0 + (24+1*size_t.sizeof)))) : null; + if (_len286) deallocate ~= cast()_ptr286; + auto _list287 = WitString(_ptr286[0.._len286]); + + _option288 = Option!(WitString).makeSome(_list287); + } else { + _option288 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.event.imports.BedrockFormResponseEventData _record289 = { + player: _handle283, + formId: *(cast(uint*)(arg0 + 20)), + responseData: _option288, + }; + auto _payload4555 = _record289; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.bedrockFormResponseEvent(_payload4555); + break; + } + case _Tag4520.serverCommandEvent: { + auto _len291 = *(cast(size_t*)(arg0 + (16+1*size_t.sizeof))); + auto _ptr291 = _len291 ? cast(char*)(*(cast(void**)(arg0 + 16))) : null; + if (_len291) deallocate ~= cast()_ptr291; + auto _list292 = WitString(_ptr291[0.._len291]); + wit.pumpkin.plugin.event.common.ServerCommandEventData _record293 = { + command: _list292, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+2*size_t.sizeof))))) != 0, + }; + auto _payload4556 = _record293; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.serverCommandEvent(_payload4556); + break; + } + case _Tag4520.serverListPingEvent: { + auto _len295 = *(cast(size_t*)(arg0 + (16+1*size_t.sizeof))); + auto _ptr295 = _len295 ? cast(char*)(*(cast(void**)(arg0 + 16))) : null; + if (_len295) deallocate ~= cast()_ptr295; + auto _list296 = WitString(_ptr295[0.._len295]); + auto _len297 = *(cast(size_t*)(arg0 + (16+3*size_t.sizeof))); + auto _ptr297 = _len297 ? cast(char*)(*(cast(void**)(arg0 + (16+2*size_t.sizeof)))) : null; + if (_len297) deallocate ~= cast()_ptr297; + auto _list298 = WitString(_ptr297[0.._len297]); + wit.pumpkin.plugin.event.common.ServerListPingAddress _record299 = { + host: _list298, + port: cast(ushort)(cast(uint)(*(cast(ushort*)(arg0 + (16+4*size_t.sizeof))))), + }; + auto _handle300 = wit.pumpkin.plugin.event.imports.TextComponent(*(cast(uint*)(arg0 + (16+5*size_t.sizeof)))); + Option!(WitString) _option305 = void; + bool _isSome305 = (cast(uint)(*(cast(ubyte*)(arg0 + (24+6*size_t.sizeof))))) != 0; + if (_isSome305) { + auto _len303 = *(cast(size_t*)(arg0 + (24+8*size_t.sizeof))); + auto _ptr303 = _len303 ? cast(char*)(*(cast(void**)(arg0 + (24+7*size_t.sizeof)))) : null; + if (_len303) deallocate ~= cast()_ptr303; + auto _list304 = WitString(_ptr303[0.._len303]); + + _option305 = Option!(WitString).makeSome(_list304); + } else { + _option305 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.event.imports.ServerListPingEventData _record306 = { + hostname: _list296, + address: _record299, + motd: _handle300, + maxPlayers: *(cast(uint*)(arg0 + (20+5*size_t.sizeof))), + numPlayers: *(cast(uint*)(arg0 + (24+5*size_t.sizeof))), + favicon: _option305, + }; + auto _payload4557 = _record306; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.serverListPingEvent(_payload4557); + break; + } + case _Tag4520.serverLoadEvent: { + wit.pumpkin.plugin.event.common.ServerLoadEventData _record308 = { + loadType: cast(wit.pumpkin.plugin.event.common.ServerLoadType)(cast(uint)(*(cast(ubyte*)(arg0 + 16)))), + }; + auto _payload4558 = _record308; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.serverLoadEvent(_payload4558); + break; + } + case _Tag4520.spawnChangeEvent: { + auto _handle310 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.common.common.BlockPos _record311 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + wit.pumpkin.plugin.common.common.BlockPos _record312 = { + x: cast(int)(*(cast(uint*)(arg0 + 40))), + y: cast(int)(*(cast(uint*)(arg0 + 44))), + z: cast(int)(*(cast(uint*)(arg0 + 48))), + }; + wit.pumpkin.plugin.event.imports.SpawnChangeEventData _record313 = { + targetWorld: _handle310, + previousPosition: _record311, + previousYaw: *(cast(float*)(arg0 + 32)), + previousPitch: *(cast(float*)(arg0 + 36)), + newPosition: _record312, + newYaw: *(cast(float*)(arg0 + 52)), + newPitch: *(cast(float*)(arg0 + 56)), + }; + auto _payload4559 = _record313; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.spawnChangeEvent(_payload4559); + break; + } + case _Tag4520.serverBroadcastEvent: { + auto _handle315 = wit.pumpkin.plugin.event.imports.TextComponent(*(cast(uint*)(arg0 + 16))); + auto _handle316 = wit.pumpkin.plugin.event.imports.TextComponent(*(cast(uint*)(arg0 + 20))); + wit.pumpkin.plugin.event.imports.ServerBroadcastEventData _record317 = { + message: _handle315, + sender: _handle316, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4560 = _record317; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.serverBroadcastEvent(_payload4560); + break; + } + case _Tag4520.serverTickStartEvent: { + wit.pumpkin.plugin.event.common.ServerTickStartEventData _record319 = { + tick: cast(int)(*(cast(uint*)(arg0 + 16))), + }; + auto _payload4561 = _record319; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.serverTickStartEvent(_payload4561); + break; + } + case _Tag4520.serverTickEndEvent: { + wit.pumpkin.plugin.event.common.ServerTickEndEventData _record321 = { + tick: cast(int)(*(cast(uint*)(arg0 + 16))), + durationNanos: cast(long)(*(cast(ulong*)(arg0 + 24))), + }; + auto _payload4562 = _record321; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.serverTickEndEvent(_payload4562); + break; + } + case _Tag4520.packetReceivedEvent: { + auto _handle323 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.common.ServerboundPacket _variant1396 = void; + auto _tag1396 = cast(uint)(*(cast(ubyte*)(arg0 + 24))); + alias _Tag1396 = wit.pumpkin.plugin.event.common.ServerboundPacket.Tag; + final switch (cast(wit.pumpkin.plugin.event.common.ServerboundPacket.Tag)_tag1396) { + case _Tag1396.java: { + wit.pumpkin.plugin.java_packets.common.ServerboundPacket _variant698 = void; + auto _tag698 = cast(uint)(*(cast(ubyte*)(arg0 + 32))); + alias _Tag698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.Tag; + final switch (cast(wit.pumpkin.plugin.java_packets.common.ServerboundPacket.Tag)_tag698) { + case _Tag698.configSAcceptCodeOfConduct: { + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.configSAcceptCodeOfConduct(); + break; + } + case _Tag698.configSAcknowledgeFinishConfig: { + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.configSAcknowledgeFinishConfig(); + break; + } + case _Tag698.configSClientInformationConfig: { + auto _len328 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr328 = _len328 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len328) deallocate ~= cast()_ptr328; + auto _list329 = WitString(_ptr328[0.._len328]); + wit.pumpkin.plugin.java_packets.common.ConfigSClientInformationConfig _record330 = { + locale: _list329, + viewDistance: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (40+2*size_t.sizeof))))), + chatMode: cast(int)(*(cast(uint*)(arg0 + (44+2*size_t.sizeof)))), + chatColors: (cast(uint)(*(cast(ubyte*)(arg0 + (48+2*size_t.sizeof))))) != 0, + skinParts: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (49+2*size_t.sizeof))))), + mainHand: cast(int)(*(cast(uint*)(arg0 + (52+2*size_t.sizeof)))), + textFiltering: (cast(uint)(*(cast(ubyte*)(arg0 + (56+2*size_t.sizeof))))) != 0, + serverListing: (cast(uint)(*(cast(ubyte*)(arg0 + (57+2*size_t.sizeof))))) != 0, + }; + auto _payload701 = _record330; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.configSClientInformationConfig(_payload701); + break; + } + case _Tag698.configSConfigCookieResponse: { + auto _len332 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr332 = _len332 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len332) deallocate ~= cast()_ptr332; + auto _list333 = WitString(_ptr332[0.._len332]); + Option!(WitList!(ubyte)) _option338 = void; + bool _isSome338 = (cast(uint)(*(cast(ubyte*)(arg0 + (40+3*size_t.sizeof))))) != 0; + if (_isSome338) { + auto _len336 = *(cast(size_t*)(arg0 + (40+5*size_t.sizeof))); + auto _ptr336 = _len336 ? cast(ubyte*)(*(cast(void**)(arg0 + (40+4*size_t.sizeof)))) : null; + if (_len336) deallocate ~= cast()_ptr336; + auto _list337 = WitList!(ubyte)(_ptr336[0.._len336]); + + _option338 = Option!(WitList!(ubyte)).makeSome(_list337); + } else { + _option338 = Option!(WitList!(ubyte)).makeNone; + } + wit.pumpkin.plugin.java_packets.common.ConfigSConfigCookieResponse _record339 = { + key: _list333, + hasPayload: (cast(uint)(*(cast(ubyte*)(arg0 + (40+2*size_t.sizeof))))) != 0, + payload: _option338, + }; + auto _payload702 = _record339; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.configSConfigCookieResponse(_payload702); + break; + } + case _Tag698.configSCustomClickAction: { + auto _len341 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr341 = _len341 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len341) deallocate ~= cast()_ptr341; + auto _list342 = WitString(_ptr341[0.._len341]); + Option!(WitList!(ubyte)) _option347 = void; + bool _isSome347 = (cast(uint)(*(cast(ubyte*)(arg0 + (40+2*size_t.sizeof))))) != 0; + if (_isSome347) { + auto _len345 = *(cast(size_t*)(arg0 + (40+4*size_t.sizeof))); + auto _ptr345 = _len345 ? cast(ubyte*)(*(cast(void**)(arg0 + (40+3*size_t.sizeof)))) : null; + if (_len345) deallocate ~= cast()_ptr345; + auto _list346 = WitList!(ubyte)(_ptr345[0.._len345]); + + _option347 = Option!(WitList!(ubyte)).makeSome(_list346); + } else { + _option347 = Option!(WitList!(ubyte)).makeNone; + } + wit.pumpkin.plugin.java_packets.common.ConfigSCustomClickAction _record348 = { + actionId: _list342, + payload: _option347, + }; + auto _payload703 = _record348; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.configSCustomClickAction(_payload703); + break; + } + case _Tag698.configSKeepAlive: { + wit.pumpkin.plugin.java_packets.common.ConfigSKeepAlive _record350 = { + keepAliveId: cast(long)(*(cast(ulong*)(arg0 + 40))), + }; + auto _payload704 = _record350; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.configSKeepAlive(_payload704); + break; + } + case _Tag698.configSKnownPacks: { + auto _listSrcPtr355 = *(cast(void**)(arg0 + 40)); + auto _listLen355 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _list355 = _listLen355 ? wit.common.mallocSlice!(WitString)(_listLen355) : []; + assert(!_listLen355 || _list355.ptr); + if (_listLen355) deallocate ~= cast(void*)_list355.ptr; + foreach (_elem352_idx, ref _elem352; _list355) { + const auto _base352 = _listSrcPtr355 + _elem352_idx * (2*size_t.sizeof); + auto _len353 = *(cast(size_t*)(_base352 + size_t.sizeof)); + auto _ptr353 = _len353 ? cast(char*)(*(cast(void**)(_base352 + 0))) : null; + if (_len353) deallocate ~= cast()_ptr353; + auto _list354 = WitString(_ptr353[0.._len353]); + _elem352 = _list354; + } + if (_listLen355) deallocate ~= _listSrcPtr355; + auto _witList356 = WitList!(WitString)(_list355); + wit.pumpkin.plugin.java_packets.common.ConfigSKnownPacks _record357 = { + knownPacks: _witList356, + }; + auto _payload705 = _record357; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.configSKnownPacks(_payload705); + break; + } + case _Tag698.configSPluginMessage: { + auto _len359 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr359 = _len359 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len359) deallocate ~= cast()_ptr359; + auto _list360 = WitString(_ptr359[0.._len359]); + auto _len361 = *(cast(size_t*)(arg0 + (40+3*size_t.sizeof))); + auto _ptr361 = _len361 ? cast(ubyte*)(*(cast(void**)(arg0 + (40+2*size_t.sizeof)))) : null; + if (_len361) deallocate ~= cast()_ptr361; + auto _list362 = WitList!(ubyte)(_ptr361[0.._len361]); + wit.pumpkin.plugin.java_packets.common.ConfigSPluginMessage _record363 = { + channel: _list360, + data: _list362, + }; + auto _payload706 = _record363; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.configSPluginMessage(_payload706); + break; + } + case _Tag698.configSConfigPong: { + wit.pumpkin.plugin.java_packets.common.ConfigSConfigPong _record365 = { + id: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload707 = _record365; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.configSConfigPong(_payload707); + break; + } + case _Tag698.configSConfigResourcePack: { + wit.pumpkin.plugin.uuid.common.Uuid _record367 = { + high: *(cast(ulong*)(arg0 + 40)), + low: *(cast(ulong*)(arg0 + 48)), + }; + wit.pumpkin.plugin.java_packets.common.ConfigSConfigResourcePack _record368 = { + uuid: _record367, + result: cast(int)(*(cast(uint*)(arg0 + 56))), + }; + auto _payload708 = _record368; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.configSConfigResourcePack(_payload708); + break; + } + case _Tag698.loginSLoginCookieResponse: { + auto _len370 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr370 = _len370 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len370) deallocate ~= cast()_ptr370; + auto _list371 = WitString(_ptr370[0.._len370]); + Option!(WitList!(ubyte)) _option376 = void; + bool _isSome376 = (cast(uint)(*(cast(ubyte*)(arg0 + (40+2*size_t.sizeof))))) != 0; + if (_isSome376) { + auto _len374 = *(cast(size_t*)(arg0 + (40+4*size_t.sizeof))); + auto _ptr374 = _len374 ? cast(ubyte*)(*(cast(void**)(arg0 + (40+3*size_t.sizeof)))) : null; + if (_len374) deallocate ~= cast()_ptr374; + auto _list375 = WitList!(ubyte)(_ptr374[0.._len374]); + + _option376 = Option!(WitList!(ubyte)).makeSome(_list375); + } else { + _option376 = Option!(WitList!(ubyte)).makeNone; + } + wit.pumpkin.plugin.java_packets.common.LoginSLoginCookieResponse _record377 = { + key: _list371, + payload: _option376, + }; + auto _payload709 = _record377; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.loginSLoginCookieResponse(_payload709); + break; + } + case _Tag698.loginSLoginAcknowledged: { + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.loginSLoginAcknowledged(); + break; + } + case _Tag698.loginSLoginStart: { + auto _len380 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr380 = _len380 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len380) deallocate ~= cast()_ptr380; + auto _list381 = WitString(_ptr380[0.._len380]); + wit.pumpkin.plugin.uuid.common.Uuid _record382 = { + high: *(cast(ulong*)(arg0 + (40+2*size_t.sizeof))), + low: *(cast(ulong*)(arg0 + (48+2*size_t.sizeof))), + }; + wit.pumpkin.plugin.java_packets.common.LoginSLoginStart _record383 = { + name: _list381, + uuid: _record382, + }; + auto _payload711 = _record383; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.loginSLoginStart(_payload711); + break; + } + case _Tag698.loginSLoginPluginResponse: { + Option!(WitList!(ubyte)) _option389 = void; + bool _isSome389 = (cast(uint)(*(cast(ubyte*)(arg0 + (40+1*size_t.sizeof))))) != 0; + if (_isSome389) { + auto _len387 = *(cast(size_t*)(arg0 + (40+3*size_t.sizeof))); + auto _ptr387 = _len387 ? cast(ubyte*)(*(cast(void**)(arg0 + (40+2*size_t.sizeof)))) : null; + if (_len387) deallocate ~= cast()_ptr387; + auto _list388 = WitList!(ubyte)(_ptr387[0.._len387]); + + _option389 = Option!(WitList!(ubyte)).makeSome(_list388); + } else { + _option389 = Option!(WitList!(ubyte)).makeNone; + } + wit.pumpkin.plugin.java_packets.common.LoginSLoginPluginResponse _record390 = { + messageId: cast(int)(*(cast(uint*)(arg0 + 40))), + data: _option389, + }; + auto _payload712 = _record390; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.loginSLoginPluginResponse(_payload712); + break; + } + case _Tag698.sAttack: { + wit.pumpkin.plugin.java_packets.common.SAttack _record392 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload713 = _record392; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sAttack(_payload713); + break; + } + case _Tag698.sBlockEntityTagQuery: { + auto _tuple394 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + cast(int)(*(cast(uint*)(arg0 + 52))), + ); + wit.pumpkin.plugin.java_packets.common.SBlockEntityTagQuery _record395 = { + transactionId: cast(int)(*(cast(uint*)(arg0 + 40))), + location: _tuple394, + }; + auto _payload714 = _record395; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sBlockEntityTagQuery(_payload714); + break; + } + case _Tag698.sBundleItemSelected: { + wit.pumpkin.plugin.java_packets.common.SBundleItemSelected _record397 = { + slotId: cast(int)(*(cast(uint*)(arg0 + 40))), + selectedItemIndex: cast(int)(*(cast(uint*)(arg0 + 44))), + }; + auto _payload715 = _record397; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sBundleItemSelected(_payload715); + break; + } + case _Tag698.sChangeDifficulty: { + auto _len399 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr399 = _len399 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len399) deallocate ~= cast()_ptr399; + auto _list400 = WitString(_ptr399[0.._len399]); + wit.pumpkin.plugin.java_packets.common.SChangeDifficulty _record401 = { + difficulty: _list400, + }; + auto _payload716 = _record401; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sChangeDifficulty(_payload716); + break; + } + case _Tag698.sChangeGameMode: { + auto _len403 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr403 = _len403 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len403) deallocate ~= cast()_ptr403; + auto _list404 = WitString(_ptr403[0.._len403]); + wit.pumpkin.plugin.java_packets.common.SChangeGameMode _record405 = { + gameMode: _list404, + }; + auto _payload717 = _record405; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sChangeGameMode(_payload717); + break; + } + case _Tag698.sChatAck: { + wit.pumpkin.plugin.java_packets.common.SChatAck _record407 = { + offset: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload718 = _record407; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sChatAck(_payload718); + break; + } + case _Tag698.sChatCommand: { + auto _len409 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr409 = _len409 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len409) deallocate ~= cast()_ptr409; + auto _list410 = WitString(_ptr409[0.._len409]); + wit.pumpkin.plugin.java_packets.common.SChatCommand _record411 = { + command: _list410, + }; + auto _payload719 = _record411; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sChatCommand(_payload719); + break; + } + case _Tag698.sChatCommandSigned: { + auto _len413 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr413 = _len413 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len413) deallocate ~= cast()_ptr413; + auto _list414 = WitString(_ptr413[0.._len413]); + auto _listSrcPtr421 = *(cast(void**)(arg0 + (56+2*size_t.sizeof))); + auto _listLen421 = *(cast(size_t*)(arg0 + (56+3*size_t.sizeof))); + auto _list421 = _listLen421 ? wit.common.mallocSlice!(wit.pumpkin.plugin.java_packets.common.ArgumentSignature)(_listLen421) : []; + assert(!_listLen421 || _list421.ptr); + if (_listLen421) deallocate ~= cast(void*)_list421.ptr; + foreach (_elem415_idx, ref _elem415; _list421) { + const auto _base415 = _listSrcPtr421 + _elem415_idx * (4*size_t.sizeof); + auto _len416 = *(cast(size_t*)(_base415 + size_t.sizeof)); + auto _ptr416 = _len416 ? cast(char*)(*(cast(void**)(_base415 + 0))) : null; + if (_len416) deallocate ~= cast()_ptr416; + auto _list417 = WitString(_ptr416[0.._len416]); + auto _len418 = *(cast(size_t*)(_base415 + (3*size_t.sizeof))); + auto _ptr418 = _len418 ? cast(ubyte*)(*(cast(void**)(_base415 + (2*size_t.sizeof)))) : null; + if (_len418) deallocate ~= cast()_ptr418; + auto _list419 = WitList!(ubyte)(_ptr418[0.._len418]); + wit.pumpkin.plugin.java_packets.common.ArgumentSignature _record420 = { + name: _list417, + signature: _list419, + }; + _elem415 = _record420; + } + if (_listLen421) deallocate ~= _listSrcPtr421; + auto _witList422 = WitList!(wit.pumpkin.plugin.java_packets.common.ArgumentSignature)(_list421); + auto _len423 = *(cast(size_t*)(arg0 + (56+6*size_t.sizeof))); + auto _ptr423 = _len423 ? cast(ubyte*)(*(cast(void**)(arg0 + (56+5*size_t.sizeof)))) : null; + if (_len423) deallocate ~= cast()_ptr423; + auto _list424 = WitList!(ubyte)(_ptr423[0.._len423]); + wit.pumpkin.plugin.java_packets.common.SChatCommandSigned _record425 = { + command: _list414, + timestamp: cast(long)(*(cast(ulong*)(arg0 + (40+2*size_t.sizeof)))), + salt: cast(long)(*(cast(ulong*)(arg0 + (48+2*size_t.sizeof)))), + argumentSignatures: _witList422, + messageCount: cast(int)(*(cast(uint*)(arg0 + (56+4*size_t.sizeof)))), + acknowledged: _list424, + checksum: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (56+7*size_t.sizeof))))), + }; + auto _payload720 = _record425; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sChatCommandSigned(_payload720); + break; + } + case _Tag698.sChatMessage: { + auto _len427 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr427 = _len427 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len427) deallocate ~= cast()_ptr427; + auto _list428 = WitString(_ptr427[0.._len427]); + Option!(WitList!(ubyte)) _option433 = void; + bool _isSome433 = (cast(uint)(*(cast(ubyte*)(arg0 + (56+2*size_t.sizeof))))) != 0; + if (_isSome433) { + auto _len431 = *(cast(size_t*)(arg0 + (56+4*size_t.sizeof))); + auto _ptr431 = _len431 ? cast(ubyte*)(*(cast(void**)(arg0 + (56+3*size_t.sizeof)))) : null; + if (_len431) deallocate ~= cast()_ptr431; + auto _list432 = WitList!(ubyte)(_ptr431[0.._len431]); + + _option433 = Option!(WitList!(ubyte)).makeSome(_list432); + } else { + _option433 = Option!(WitList!(ubyte)).makeNone; + } + auto _len434 = *(cast(size_t*)(arg0 + (56+7*size_t.sizeof))); + auto _ptr434 = _len434 ? cast(ubyte*)(*(cast(void**)(arg0 + (56+6*size_t.sizeof)))) : null; + if (_len434) deallocate ~= cast()_ptr434; + auto _list435 = WitList!(ubyte)(_ptr434[0.._len434]); + wit.pumpkin.plugin.java_packets.common.SChatMessage _record436 = { + message: _list428, + timestamp: cast(long)(*(cast(ulong*)(arg0 + (40+2*size_t.sizeof)))), + salt: cast(long)(*(cast(ulong*)(arg0 + (48+2*size_t.sizeof)))), + signature: _option433, + messageCount: cast(int)(*(cast(uint*)(arg0 + (56+5*size_t.sizeof)))), + acknowledged: _list435, + checksum: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (56+8*size_t.sizeof))))), + }; + auto _payload721 = _record436; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sChatMessage(_payload721); + break; + } + case _Tag698.sChunkBatch: { + wit.pumpkin.plugin.java_packets.common.SChunkBatch _record438 = { + chunksPerTick: *(cast(float*)(arg0 + 40)), + }; + auto _payload722 = _record438; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sChunkBatch(_payload722); + break; + } + case _Tag698.sClickSlot: { + auto _listSrcPtr444 = *(cast(void**)(arg0 + (56+1*size_t.sizeof))); + auto _listLen444 = *(cast(size_t*)(arg0 + (56+2*size_t.sizeof))); + auto _list444 = _listLen444 ? wit.common.mallocSlice!(Tuple!(int, WitString))(_listLen444) : []; + assert(!_listLen444 || _list444.ptr); + if (_listLen444) deallocate ~= cast(void*)_list444.ptr; + foreach (_elem440_idx, ref _elem440; _list444) { + const auto _base440 = _listSrcPtr444 + _elem440_idx * (3*size_t.sizeof); + auto _len441 = *(cast(size_t*)(_base440 + (2*size_t.sizeof))); + auto _ptr441 = _len441 ? cast(char*)(*(cast(void**)(_base440 + size_t.sizeof))) : null; + if (_len441) deallocate ~= cast()_ptr441; + auto _list442 = WitString(_ptr441[0.._len441]); + auto _tuple443 = Tuple!(int, WitString)( + cast(int)(*(cast(uint*)(_base440 + 0))), + _list442, + ); + _elem440 = _tuple443; + } + if (_listLen444) deallocate ~= _listSrcPtr444; + auto _witList445 = WitList!(Tuple!(int, WitString))(_list444); + auto _len446 = *(cast(size_t*)(arg0 + (56+4*size_t.sizeof))); + auto _ptr446 = _len446 ? cast(char*)(*(cast(void**)(arg0 + (56+3*size_t.sizeof)))) : null; + if (_len446) deallocate ~= cast()_ptr446; + auto _list447 = WitString(_ptr446[0.._len446]); + wit.pumpkin.plugin.java_packets.common.SClickSlot _record448 = { + syncId: cast(int)(*(cast(uint*)(arg0 + 40))), + revision: cast(int)(*(cast(uint*)(arg0 + 44))), + slot: cast(int)(*(cast(uint*)(arg0 + 48))), + button: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 52)))), + mode: cast(wit.pumpkin.plugin.java_packets.common.SlotActionType)(cast(uint)(*(cast(ubyte*)(arg0 + 53)))), + lengthOfArray: cast(int)(*(cast(uint*)(arg0 + 56))), + arrayOfChangedSlots: _witList445, + carriedItem: _list447, + }; + auto _payload723 = _record448; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sClickSlot(_payload723); + break; + } + case _Tag698.sClientCommand: { + wit.pumpkin.plugin.java_packets.common.SClientCommand _record450 = { + actionId: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload724 = _record450; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sClientCommand(_payload724); + break; + } + case _Tag698.sClientInformationPlay: { + auto _len452 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr452 = _len452 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len452) deallocate ~= cast()_ptr452; + auto _list453 = WitString(_ptr452[0.._len452]); + wit.pumpkin.plugin.java_packets.common.SClientInformationPlay _record454 = { + locale: _list453, + viewDistance: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (40+2*size_t.sizeof))))), + chatMode: cast(int)(*(cast(uint*)(arg0 + (44+2*size_t.sizeof)))), + chatColors: (cast(uint)(*(cast(ubyte*)(arg0 + (48+2*size_t.sizeof))))) != 0, + skinParts: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (49+2*size_t.sizeof))))), + mainHand: cast(int)(*(cast(uint*)(arg0 + (52+2*size_t.sizeof)))), + textFiltering: (cast(uint)(*(cast(ubyte*)(arg0 + (56+2*size_t.sizeof))))) != 0, + serverListing: (cast(uint)(*(cast(ubyte*)(arg0 + (57+2*size_t.sizeof))))) != 0, + }; + auto _payload725 = _record454; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sClientInformationPlay(_payload725); + break; + } + case _Tag698.sClientTickEnd: { + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sClientTickEnd(); + break; + } + case _Tag698.sCloseContainer: { + wit.pumpkin.plugin.java_packets.common.SCloseContainer _record457 = { + windowId: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload727 = _record457; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sCloseContainer(_payload727); + break; + } + case _Tag698.sCommandSuggestion: { + auto _len459 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _ptr459 = _len459 ? cast(char*)(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))) : null; + if (_len459) deallocate ~= cast()_ptr459; + auto _list460 = WitString(_ptr459[0.._len459]); + wit.pumpkin.plugin.java_packets.common.SCommandSuggestion _record461 = { + id: cast(int)(*(cast(uint*)(arg0 + 40))), + command: _list460, + }; + auto _payload728 = _record461; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sCommandSuggestion(_payload728); + break; + } + case _Tag698.sConfigurationAcknowledged: { + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sConfigurationAcknowledged(); + break; + } + case _Tag698.sContainerButtonClick: { + wit.pumpkin.plugin.java_packets.common.SContainerButtonClick _record464 = { + windowId: cast(int)(*(cast(uint*)(arg0 + 40))), + buttonId: cast(int)(*(cast(uint*)(arg0 + 44))), + }; + auto _payload730 = _record464; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sContainerButtonClick(_payload730); + break; + } + case _Tag698.sContainerSlotStateChanged: { + wit.pumpkin.plugin.java_packets.common.SContainerSlotStateChanged _record466 = { + slotId: cast(int)(*(cast(uint*)(arg0 + 40))), + containerId: cast(int)(*(cast(uint*)(arg0 + 44))), + newState: (cast(uint)(*(cast(ubyte*)(arg0 + 48)))) != 0, + }; + auto _payload731 = _record466; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sContainerSlotStateChanged(_payload731); + break; + } + case _Tag698.sCookieResponse: { + auto _len468 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr468 = _len468 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len468) deallocate ~= cast()_ptr468; + auto _list469 = WitString(_ptr468[0.._len468]); + Option!(WitList!(ubyte)) _option474 = void; + bool _isSome474 = (cast(uint)(*(cast(ubyte*)(arg0 + (40+2*size_t.sizeof))))) != 0; + if (_isSome474) { + auto _len472 = *(cast(size_t*)(arg0 + (40+4*size_t.sizeof))); + auto _ptr472 = _len472 ? cast(ubyte*)(*(cast(void**)(arg0 + (40+3*size_t.sizeof)))) : null; + if (_len472) deallocate ~= cast()_ptr472; + auto _list473 = WitList!(ubyte)(_ptr472[0.._len472]); + + _option474 = Option!(WitList!(ubyte)).makeSome(_list473); + } else { + _option474 = Option!(WitList!(ubyte)).makeNone; + } + wit.pumpkin.plugin.java_packets.common.SCookieResponse _record475 = { + key: _list469, + payload: _option474, + }; + auto _payload732 = _record475; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sCookieResponse(_payload732); + break; + } + case _Tag698.sCustomClickAction: { + auto _len477 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr477 = _len477 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len477) deallocate ~= cast()_ptr477; + auto _list478 = WitString(_ptr477[0.._len477]); + Option!(WitList!(ubyte)) _option483 = void; + bool _isSome483 = (cast(uint)(*(cast(ubyte*)(arg0 + (40+2*size_t.sizeof))))) != 0; + if (_isSome483) { + auto _len481 = *(cast(size_t*)(arg0 + (40+4*size_t.sizeof))); + auto _ptr481 = _len481 ? cast(ubyte*)(*(cast(void**)(arg0 + (40+3*size_t.sizeof)))) : null; + if (_len481) deallocate ~= cast()_ptr481; + auto _list482 = WitList!(ubyte)(_ptr481[0.._len481]); + + _option483 = Option!(WitList!(ubyte)).makeSome(_list482); + } else { + _option483 = Option!(WitList!(ubyte)).makeNone; + } + wit.pumpkin.plugin.java_packets.common.SCustomClickAction _record484 = { + actionId: _list478, + payload: _option483, + }; + auto _payload733 = _record484; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sCustomClickAction(_payload733); + break; + } + case _Tag698.sCustomPayload: { + auto _len486 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr486 = _len486 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len486) deallocate ~= cast()_ptr486; + auto _list487 = WitString(_ptr486[0.._len486]); + auto _len488 = *(cast(size_t*)(arg0 + (40+3*size_t.sizeof))); + auto _ptr488 = _len488 ? cast(ubyte*)(*(cast(void**)(arg0 + (40+2*size_t.sizeof)))) : null; + if (_len488) deallocate ~= cast()_ptr488; + auto _list489 = WitList!(ubyte)(_ptr488[0.._len488]); + wit.pumpkin.plugin.java_packets.common.SCustomPayload _record490 = { + channel: _list487, + data: _list489, + }; + auto _payload734 = _record490; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sCustomPayload(_payload734); + break; + } + case _Tag698.sDebugSampleSubscription: { + wit.pumpkin.plugin.java_packets.common.SDebugSampleSubscription _record492 = { + sampleType: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload735 = _record492; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sDebugSampleSubscription(_payload735); + break; + } + case _Tag698.sDebugSubscriptionRequest: { + wit.pumpkin.plugin.java_packets.common.SDebugSubscriptionRequest _record494 = { + sampleType: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload736 = _record494; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sDebugSubscriptionRequest(_payload736); + break; + } + case _Tag698.sEditBook: { + auto _listSrcPtr499 = *(cast(void**)(arg0 + (40+1*size_t.sizeof))); + auto _listLen499 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _list499 = _listLen499 ? wit.common.mallocSlice!(WitString)(_listLen499) : []; + assert(!_listLen499 || _list499.ptr); + if (_listLen499) deallocate ~= cast(void*)_list499.ptr; + foreach (_elem496_idx, ref _elem496; _list499) { + const auto _base496 = _listSrcPtr499 + _elem496_idx * (2*size_t.sizeof); + auto _len497 = *(cast(size_t*)(_base496 + size_t.sizeof)); + auto _ptr497 = _len497 ? cast(char*)(*(cast(void**)(_base496 + 0))) : null; + if (_len497) deallocate ~= cast()_ptr497; + auto _list498 = WitString(_ptr497[0.._len497]); + _elem496 = _list498; + } + if (_listLen499) deallocate ~= _listSrcPtr499; + auto _witList500 = WitList!(WitString)(_list499); + Option!(WitString) _option505 = void; + bool _isSome505 = (cast(uint)(*(cast(ubyte*)(arg0 + (40+3*size_t.sizeof))))) != 0; + if (_isSome505) { + auto _len503 = *(cast(size_t*)(arg0 + (40+5*size_t.sizeof))); + auto _ptr503 = _len503 ? cast(char*)(*(cast(void**)(arg0 + (40+4*size_t.sizeof)))) : null; + if (_len503) deallocate ~= cast()_ptr503; + auto _list504 = WitString(_ptr503[0.._len503]); + + _option505 = Option!(WitString).makeSome(_list504); + } else { + _option505 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.java_packets.common.SEditBook _record506 = { + slot: cast(int)(*(cast(uint*)(arg0 + 40))), + pages: _witList500, + title: _option505, + }; + auto _payload737 = _record506; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sEditBook(_payload737); + break; + } + case _Tag698.sEntityTagQuery: { + wit.pumpkin.plugin.java_packets.common.SEntityTagQuery _record508 = { + transactionId: cast(int)(*(cast(uint*)(arg0 + 40))), + entityId: cast(int)(*(cast(uint*)(arg0 + 44))), + }; + auto _payload738 = _record508; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sEntityTagQuery(_payload738); + break; + } + case _Tag698.sInteract: { + Option!(Tuple!(double, double, double)) _option513 = void; + bool _isSome513 = (cast(uint)(*(cast(ubyte*)(arg0 + 48)))) != 0; + if (_isSome513) { + auto _tuple512 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 56)), + *(cast(double*)(arg0 + 64)), + *(cast(double*)(arg0 + 72)), + ); + + _option513 = Option!(Tuple!(double, double, double)).makeSome(_tuple512); + } else { + _option513 = Option!(Tuple!(double, double, double)).makeNone; + } + Option!(int) _option516 = void; + bool _isSome516 = (cast(uint)(*(cast(ubyte*)(arg0 + 80)))) != 0; + if (_isSome516) { + + _option516 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + 84)))); + } else { + _option516 = Option!(int).makeNone; + } + wit.pumpkin.plugin.java_packets.common.SInteract _record517 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + rType: cast(int)(*(cast(uint*)(arg0 + 44))), + targetPosition: _option513, + hand: _option516, + sneaking: (cast(uint)(*(cast(ubyte*)(arg0 + 88)))) != 0, + }; + auto _payload739 = _record517; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sInteract(_payload739); + break; + } + case _Tag698.sJigsawGenerate: { + auto _tuple519 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 40))), + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + ); + wit.pumpkin.plugin.java_packets.common.SJigsawGenerate _record520 = { + pos: _tuple519, + levels: cast(int)(*(cast(uint*)(arg0 + 52))), + keepJigsaws: (cast(uint)(*(cast(ubyte*)(arg0 + 56)))) != 0, + }; + auto _payload740 = _record520; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sJigsawGenerate(_payload740); + break; + } + case _Tag698.sKeepAlive: { + wit.pumpkin.plugin.java_packets.common.SKeepAlive _record522 = { + keepAliveId: cast(long)(*(cast(ulong*)(arg0 + 40))), + }; + auto _payload741 = _record522; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sKeepAlive(_payload741); + break; + } + case _Tag698.sLockDifficulty: { + wit.pumpkin.plugin.java_packets.common.SLockDifficulty _record524 = { + locked: (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0, + }; + auto _payload742 = _record524; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sLockDifficulty(_payload742); + break; + } + case _Tag698.sMoveVehicle: { + wit.pumpkin.plugin.java_packets.common.SMoveVehicle _record526 = { + x: *(cast(double*)(arg0 + 40)), + y: *(cast(double*)(arg0 + 48)), + z: *(cast(double*)(arg0 + 56)), + yaw: *(cast(float*)(arg0 + 64)), + pitch: *(cast(float*)(arg0 + 68)), + onGround: (cast(uint)(*(cast(ubyte*)(arg0 + 72)))) != 0, + }; + auto _payload743 = _record526; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sMoveVehicle(_payload743); + break; + } + case _Tag698.sPaddleBoat: { + wit.pumpkin.plugin.java_packets.common.SPaddleBoat _record528 = { + leftPaddle: (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0, + rightPaddle: (cast(uint)(*(cast(ubyte*)(arg0 + 41)))) != 0, + }; + auto _payload744 = _record528; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sPaddleBoat(_payload744); + break; + } + case _Tag698.sPickItemFromBlock: { + auto _tuple530 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 40))), + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + ); + wit.pumpkin.plugin.java_packets.common.SPickItemFromBlock _record531 = { + pos: _tuple530, + includeData: (cast(uint)(*(cast(ubyte*)(arg0 + 52)))) != 0, + }; + auto _payload745 = _record531; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sPickItemFromBlock(_payload745); + break; + } + case _Tag698.sPickItemFromEntity: { + wit.pumpkin.plugin.java_packets.common.SPickItemFromEntity _record533 = { + id: cast(int)(*(cast(uint*)(arg0 + 40))), + includeData: (cast(uint)(*(cast(ubyte*)(arg0 + 44)))) != 0, + }; + auto _payload746 = _record533; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sPickItemFromEntity(_payload746); + break; + } + case _Tag698.sPlayPingRequest: { + wit.pumpkin.plugin.java_packets.common.SPlayPingRequest _record535 = { + payload: cast(long)(*(cast(ulong*)(arg0 + 40))), + }; + auto _payload747 = _record535; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sPlayPingRequest(_payload747); + break; + } + case _Tag698.sPlaceRecipe: { + wit.pumpkin.plugin.java_packets.common.SPlaceRecipe _record537 = { + containerId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 40)))), + recipeDisplayId: cast(int)(*(cast(uint*)(arg0 + 44))), + useMaxItems: (cast(uint)(*(cast(ubyte*)(arg0 + 48)))) != 0, + }; + auto _payload748 = _record537; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sPlaceRecipe(_payload748); + break; + } + case _Tag698.sPlayerAbilities: { + Option!(float) _option541 = void; + bool _isSome541 = (cast(uint)(*(cast(ubyte*)(arg0 + 44)))) != 0; + if (_isSome541) { + + _option541 = Option!(float).makeSome(*(cast(float*)(arg0 + 48))); + } else { + _option541 = Option!(float).makeNone; + } + Option!(float) _option544 = void; + bool _isSome544 = (cast(uint)(*(cast(ubyte*)(arg0 + 52)))) != 0; + if (_isSome544) { + + _option544 = Option!(float).makeSome(*(cast(float*)(arg0 + 56))); + } else { + _option544 = Option!(float).makeNone; + } + wit.pumpkin.plugin.java_packets.common.SPlayerAbilities _record545 = { + flags: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 40)))), + flySpeed: _option541, + walkSpeed: _option544, + }; + auto _payload749 = _record545; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sPlayerAbilities(_payload749); + break; + } + case _Tag698.sPlayerAction: { + auto _tuple547 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + cast(int)(*(cast(uint*)(arg0 + 52))), + ); + wit.pumpkin.plugin.java_packets.common.SPlayerAction _record548 = { + status: cast(int)(*(cast(uint*)(arg0 + 40))), + position: _tuple547, + face: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 56)))), + sequence: cast(int)(*(cast(uint*)(arg0 + 60))), + }; + auto _payload750 = _record548; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sPlayerAction(_payload750); + break; + } + case _Tag698.sPlayerCommand: { + wit.pumpkin.plugin.java_packets.common.SPlayerCommand _record550 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + action: cast(wit.pumpkin.plugin.java_packets.common.Action)(cast(uint)(*(cast(ubyte*)(arg0 + 44)))), + jumpBoost: cast(int)(*(cast(uint*)(arg0 + 48))), + }; + auto _payload751 = _record550; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sPlayerCommand(_payload751); + break; + } + case _Tag698.sSetPlayerGround: { + wit.pumpkin.plugin.java_packets.common.SSetPlayerGround _record552 = { + onGround: (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0, + }; + auto _payload752 = _record552; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sSetPlayerGround(_payload752); + break; + } + case _Tag698.sPlayerInput: { + wit.pumpkin.plugin.java_packets.common.SPlayerInput _record554 = { + input: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 40)))), + }; + auto _payload753 = _record554; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sPlayerInput(_payload753); + break; + } + case _Tag698.sPlayerLoaded: { + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sPlayerLoaded(); + break; + } + case _Tag698.sPlayerPosition: { + auto _tuple557 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 40)), + *(cast(double*)(arg0 + 48)), + *(cast(double*)(arg0 + 56)), + ); + wit.pumpkin.plugin.java_packets.common.SPlayerPosition _record558 = { + position: _tuple557, + collision: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 64)))), + }; + auto _payload755 = _record558; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sPlayerPosition(_payload755); + break; + } + case _Tag698.sPlayerPositionRotation: { + auto _tuple560 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 40)), + *(cast(double*)(arg0 + 48)), + *(cast(double*)(arg0 + 56)), + ); + wit.pumpkin.plugin.java_packets.common.SPlayerPositionRotation _record561 = { + position: _tuple560, + yaw: *(cast(float*)(arg0 + 64)), + pitch: *(cast(float*)(arg0 + 68)), + collision: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 72)))), + }; + auto _payload756 = _record561; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sPlayerPositionRotation(_payload756); + break; + } + case _Tag698.sPlayerRotation: { + wit.pumpkin.plugin.java_packets.common.SPlayerRotation _record563 = { + yaw: *(cast(float*)(arg0 + 40)), + pitch: *(cast(float*)(arg0 + 44)), + ground: (cast(uint)(*(cast(ubyte*)(arg0 + 48)))) != 0, + }; + auto _payload757 = _record563; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sPlayerRotation(_payload757); + break; + } + case _Tag698.sPlayerSession: { + wit.pumpkin.plugin.uuid.common.Uuid _record565 = { + high: *(cast(ulong*)(arg0 + 40)), + low: *(cast(ulong*)(arg0 + 48)), + }; + auto _len566 = *(cast(size_t*)(arg0 + (64+1*size_t.sizeof))); + auto _ptr566 = _len566 ? cast(ubyte*)(*(cast(void**)(arg0 + 64))) : null; + if (_len566) deallocate ~= cast()_ptr566; + auto _list567 = WitList!(ubyte)(_ptr566[0.._len566]); + auto _len568 = *(cast(size_t*)(arg0 + (64+3*size_t.sizeof))); + auto _ptr568 = _len568 ? cast(ubyte*)(*(cast(void**)(arg0 + (64+2*size_t.sizeof)))) : null; + if (_len568) deallocate ~= cast()_ptr568; + auto _list569 = WitList!(ubyte)(_ptr568[0.._len568]); + wit.pumpkin.plugin.java_packets.common.SPlayerSession _record570 = { + sessionId: _record565, + expiresAt: cast(long)(*(cast(ulong*)(arg0 + 56))), + publicKey: _list567, + keySignature: _list569, + }; + auto _payload758 = _record570; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sPlayerSession(_payload758); + break; + } + case _Tag698.sPlayPong: { + wit.pumpkin.plugin.java_packets.common.SPlayPong _record572 = { + id: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload759 = _record572; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sPlayPong(_payload759); + break; + } + case _Tag698.sRecipeBookChangeSettings: { + wit.pumpkin.plugin.java_packets.common.SRecipeBookChangeSettings _record574 = { + bookType: cast(int)(*(cast(uint*)(arg0 + 40))), + isOpen: (cast(uint)(*(cast(ubyte*)(arg0 + 44)))) != 0, + isFiltering: (cast(uint)(*(cast(ubyte*)(arg0 + 45)))) != 0, + }; + auto _payload760 = _record574; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sRecipeBookChangeSettings(_payload760); + break; + } + case _Tag698.sRecipeBookSeenRecipe: { + wit.pumpkin.plugin.java_packets.common.SRecipeBookSeenRecipe _record576 = { + recipeDisplayId: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload761 = _record576; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sRecipeBookSeenRecipe(_payload761); + break; + } + case _Tag698.sRenameItem: { + auto _len578 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr578 = _len578 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len578) deallocate ~= cast()_ptr578; + auto _list579 = WitString(_ptr578[0.._len578]); + wit.pumpkin.plugin.java_packets.common.SRenameItem _record580 = { + itemName: _list579, + }; + auto _payload762 = _record580; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sRenameItem(_payload762); + break; + } + case _Tag698.sPlayResourcePack: { + wit.pumpkin.plugin.uuid.common.Uuid _record582 = { + high: *(cast(ulong*)(arg0 + 40)), + low: *(cast(ulong*)(arg0 + 48)), + }; + wit.pumpkin.plugin.java_packets.common.SPlayResourcePack _record583 = { + uuid: _record582, + result: cast(int)(*(cast(uint*)(arg0 + 56))), + }; + auto _payload763 = _record583; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sPlayResourcePack(_payload763); + break; + } + case _Tag698.sSeenAdvancement: { + wit.pumpkin.plugin.java_packets.common.SSeenAdvancement _variant589 = void; + auto _tag589 = cast(uint)(*(cast(ubyte*)(arg0 + 40))); + alias _Tag589 = wit.pumpkin.plugin.java_packets.common.SSeenAdvancement.Tag; + final switch (cast(wit.pumpkin.plugin.java_packets.common.SSeenAdvancement.Tag)_tag589) { + case _Tag589.openTab: { + auto _len586 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _ptr586 = _len586 ? cast(char*)(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))) : null; + if (_len586) deallocate ~= cast()_ptr586; + auto _list587 = WitString(_ptr586[0.._len586]); + auto _payload590 = _list587; + _variant589 = wit.pumpkin.plugin.java_packets.common.SSeenAdvancement.openTab(_payload590); + break; + } + case _Tag589.closeTab: { + _variant589 = wit.pumpkin.plugin.java_packets.common.SSeenAdvancement.closeTab(); + break; + } + } + auto _payload764 = _variant589; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sSeenAdvancement(_payload764); + break; + } + case _Tag698.sSelectTrade: { + wit.pumpkin.plugin.java_packets.common.SSelectTrade _record593 = { + selectedSlot: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload765 = _record593; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sSelectTrade(_payload765); + break; + } + case _Tag698.sSetBeacon: { + Option!(int) _option597 = void; + bool _isSome597 = (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0; + if (_isSome597) { + + _option597 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + 44)))); + } else { + _option597 = Option!(int).makeNone; + } + Option!(int) _option600 = void; + bool _isSome600 = (cast(uint)(*(cast(ubyte*)(arg0 + 48)))) != 0; + if (_isSome600) { + + _option600 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + 52)))); + } else { + _option600 = Option!(int).makeNone; + } + wit.pumpkin.plugin.java_packets.common.SSetBeacon _record601 = { + primaryEffect: _option597, + secondaryEffect: _option600, + }; + auto _payload766 = _record601; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sSetBeacon(_payload766); + break; + } + case _Tag698.sSetCommandBlock: { + auto _tuple603 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 40))), + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + ); + auto _len604 = *(cast(size_t*)(arg0 + (48+2*size_t.sizeof))); + auto _ptr604 = _len604 ? cast(char*)(*(cast(void**)(arg0 + (48+1*size_t.sizeof)))) : null; + if (_len604) deallocate ~= cast()_ptr604; + auto _list605 = WitString(_ptr604[0.._len604]); + wit.pumpkin.plugin.java_packets.common.SSetCommandBlock _record606 = { + pos: _tuple603, + command: _list605, + mode: cast(int)(*(cast(uint*)(arg0 + (48+3*size_t.sizeof)))), + flags: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (52+3*size_t.sizeof))))), + }; + auto _payload767 = _record606; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sSetCommandBlock(_payload767); + break; + } + case _Tag698.sSetCommandMinecart: { + auto _len608 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _ptr608 = _len608 ? cast(char*)(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))) : null; + if (_len608) deallocate ~= cast()_ptr608; + auto _list609 = WitString(_ptr608[0.._len608]); + wit.pumpkin.plugin.java_packets.common.SSetCommandMinecart _record610 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + command: _list609, + trackOutput: (cast(uint)(*(cast(ubyte*)(arg0 + (40+3*size_t.sizeof))))) != 0, + }; + auto _payload768 = _record610; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sSetCommandMinecart(_payload768); + break; + } + case _Tag698.sSetCreativeSlot: { + auto _len612 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _ptr612 = _len612 ? cast(char*)(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))) : null; + if (_len612) deallocate ~= cast()_ptr612; + auto _list613 = WitString(_ptr612[0.._len612]); + wit.pumpkin.plugin.java_packets.common.SSetCreativeSlot _record614 = { + slot: cast(int)(*(cast(uint*)(arg0 + 40))), + clickedItem: _list613, + }; + auto _payload769 = _record614; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sSetCreativeSlot(_payload769); + break; + } + case _Tag698.sSetGameRule: { + auto _listSrcPtr622 = *(cast(void**)(arg0 + 40)); + auto _listLen622 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _list622 = _listLen622 ? wit.common.mallocSlice!(wit.pumpkin.plugin.java_packets.common.GameRuleEntry)(_listLen622) : []; + assert(!_listLen622 || _list622.ptr); + if (_listLen622) deallocate ~= cast(void*)_list622.ptr; + foreach (_elem616_idx, ref _elem616; _list622) { + const auto _base616 = _listSrcPtr622 + _elem616_idx * (4*size_t.sizeof); + auto _len617 = *(cast(size_t*)(_base616 + size_t.sizeof)); + auto _ptr617 = _len617 ? cast(char*)(*(cast(void**)(_base616 + 0))) : null; + if (_len617) deallocate ~= cast()_ptr617; + auto _list618 = WitString(_ptr617[0.._len617]); + auto _len619 = *(cast(size_t*)(_base616 + (3*size_t.sizeof))); + auto _ptr619 = _len619 ? cast(char*)(*(cast(void**)(_base616 + (2*size_t.sizeof)))) : null; + if (_len619) deallocate ~= cast()_ptr619; + auto _list620 = WitString(_ptr619[0.._len619]); + wit.pumpkin.plugin.java_packets.common.GameRuleEntry _record621 = { + gameRuleKey: _list618, + value: _list620, + }; + _elem616 = _record621; + } + if (_listLen622) deallocate ~= _listSrcPtr622; + auto _witList623 = WitList!(wit.pumpkin.plugin.java_packets.common.GameRuleEntry)(_list622); + wit.pumpkin.plugin.java_packets.common.SSetGameRule _record624 = { + entries: _witList623, + }; + auto _payload770 = _record624; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sSetGameRule(_payload770); + break; + } + case _Tag698.sSetHeldItem: { + wit.pumpkin.plugin.java_packets.common.SSetHeldItem _record626 = { + slot: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload771 = _record626; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sSetHeldItem(_payload771); + break; + } + case _Tag698.sSetJigsawBlock: { + auto _tuple628 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 40))), + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + ); + auto _len629 = *(cast(size_t*)(arg0 + (48+2*size_t.sizeof))); + auto _ptr629 = _len629 ? cast(char*)(*(cast(void**)(arg0 + (48+1*size_t.sizeof)))) : null; + if (_len629) deallocate ~= cast()_ptr629; + auto _list630 = WitString(_ptr629[0.._len629]); + auto _len631 = *(cast(size_t*)(arg0 + (48+4*size_t.sizeof))); + auto _ptr631 = _len631 ? cast(char*)(*(cast(void**)(arg0 + (48+3*size_t.sizeof)))) : null; + if (_len631) deallocate ~= cast()_ptr631; + auto _list632 = WitString(_ptr631[0.._len631]); + auto _len633 = *(cast(size_t*)(arg0 + (48+6*size_t.sizeof))); + auto _ptr633 = _len633 ? cast(char*)(*(cast(void**)(arg0 + (48+5*size_t.sizeof)))) : null; + if (_len633) deallocate ~= cast()_ptr633; + auto _list634 = WitString(_ptr633[0.._len633]); + auto _len635 = *(cast(size_t*)(arg0 + (48+8*size_t.sizeof))); + auto _ptr635 = _len635 ? cast(char*)(*(cast(void**)(arg0 + (48+7*size_t.sizeof)))) : null; + if (_len635) deallocate ~= cast()_ptr635; + auto _list636 = WitString(_ptr635[0.._len635]); + auto _len637 = *(cast(size_t*)(arg0 + (48+10*size_t.sizeof))); + auto _ptr637 = _len637 ? cast(char*)(*(cast(void**)(arg0 + (48+9*size_t.sizeof)))) : null; + if (_len637) deallocate ~= cast()_ptr637; + auto _list638 = WitString(_ptr637[0.._len637]); + wit.pumpkin.plugin.java_packets.common.SSetJigsawBlock _record639 = { + pos: _tuple628, + name: _list630, + target: _list632, + pool: _list634, + finalState: _list636, + joint: _list638, + selectionPriority: cast(int)(*(cast(uint*)(arg0 + (48+11*size_t.sizeof)))), + placementPriority: cast(int)(*(cast(uint*)(arg0 + (52+11*size_t.sizeof)))), + }; + auto _payload772 = _record639; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sSetJigsawBlock(_payload772); + break; + } + case _Tag698.sSetStructureBlock: { + auto _tuple641 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 40))), + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + ); + auto _len642 = *(cast(size_t*)(arg0 + (56+2*size_t.sizeof))); + auto _ptr642 = _len642 ? cast(char*)(*(cast(void**)(arg0 + (56+1*size_t.sizeof)))) : null; + if (_len642) deallocate ~= cast()_ptr642; + auto _list643 = WitString(_ptr642[0.._len642]); + auto _len644 = *(cast(size_t*)(arg0 + (72+4*size_t.sizeof))); + auto _ptr644 = _len644 ? cast(char*)(*(cast(void**)(arg0 + (72+3*size_t.sizeof)))) : null; + if (_len644) deallocate ~= cast()_ptr644; + auto _list645 = WitString(_ptr644[0.._len644]); + wit.pumpkin.plugin.java_packets.common.SSetStructureBlock _record646 = { + location: _tuple641, + action: cast(int)(*(cast(uint*)(arg0 + 52))), + mode: cast(int)(*(cast(uint*)(arg0 + 56))), + name: _list643, + offsetX: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (56+3*size_t.sizeof))))), + offsetY: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (57+3*size_t.sizeof))))), + offsetZ: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (58+3*size_t.sizeof))))), + sizeX: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (59+3*size_t.sizeof))))), + sizeY: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (60+3*size_t.sizeof))))), + sizeZ: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (61+3*size_t.sizeof))))), + mirror: cast(int)(*(cast(uint*)(arg0 + (64+3*size_t.sizeof)))), + rotation: cast(int)(*(cast(uint*)(arg0 + (68+3*size_t.sizeof)))), + metadata: _list645, + integrity: *(cast(float*)(arg0 + (72+5*size_t.sizeof))), + seed: cast(long)(*(cast(ulong*)(arg0 + (72+6*size_t.sizeof)))), + flags: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (80+6*size_t.sizeof))))), + }; + auto _payload773 = _record646; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sSetStructureBlock(_payload773); + break; + } + case _Tag698.sSetTestBlock: { + auto _tuple648 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 40))), + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + ); + auto _len649 = *(cast(size_t*)(arg0 + (56+1*size_t.sizeof))); + auto _ptr649 = _len649 ? cast(char*)(*(cast(void**)(arg0 + 56))) : null; + if (_len649) deallocate ~= cast()_ptr649; + auto _list650 = WitString(_ptr649[0.._len649]); + wit.pumpkin.plugin.java_packets.common.SSetTestBlock _record651 = { + position: _tuple648, + mode: cast(wit.pumpkin.plugin.java_packets.common.TestBlockMode)(cast(uint)(*(cast(ubyte*)(arg0 + 52)))), + message: _list650, + }; + auto _payload774 = _record651; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sSetTestBlock(_payload774); + break; + } + case _Tag698.sSpectateEntity: { + wit.pumpkin.plugin.uuid.common.Uuid _record653 = { + high: *(cast(ulong*)(arg0 + 40)), + low: *(cast(ulong*)(arg0 + 48)), + }; + wit.pumpkin.plugin.java_packets.common.SSpectateEntity _record654 = { + target: _record653, + }; + auto _payload775 = _record654; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sSpectateEntity(_payload775); + break; + } + case _Tag698.sSwingArm: { + wit.pumpkin.plugin.java_packets.common.SSwingArm _record656 = { + hand: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload776 = _record656; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sSwingArm(_payload776); + break; + } + case _Tag698.sTeleportToEntity: { + wit.pumpkin.plugin.uuid.common.Uuid _record658 = { + high: *(cast(ulong*)(arg0 + 40)), + low: *(cast(ulong*)(arg0 + 48)), + }; + wit.pumpkin.plugin.java_packets.common.STeleportToEntity _record659 = { + target: _record658, + }; + auto _payload777 = _record659; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sTeleportToEntity(_payload777); + break; + } + case _Tag698.sTestInstanceBlockAction: { + auto _tuple661 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 40))), + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + ); + Option!(WitString) _option666 = void; + bool _isSome666 = (cast(uint)(*(cast(ubyte*)(arg0 + 56)))) != 0; + if (_isSome666) { + auto _len664 = *(cast(size_t*)(arg0 + (56+2*size_t.sizeof))); + auto _ptr664 = _len664 ? cast(char*)(*(cast(void**)(arg0 + (56+1*size_t.sizeof)))) : null; + if (_len664) deallocate ~= cast()_ptr664; + auto _list665 = WitString(_ptr664[0.._len664]); + + _option666 = Option!(WitString).makeSome(_list665); + } else { + _option666 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.java_packets.common.VarIntVector3 _record667 = { + x: cast(int)(*(cast(uint*)(arg0 + (56+3*size_t.sizeof)))), + y: cast(int)(*(cast(uint*)(arg0 + (60+3*size_t.sizeof)))), + z: cast(int)(*(cast(uint*)(arg0 + (64+3*size_t.sizeof)))), + }; + auto _len668 = *(cast(size_t*)(arg0 + (64+5*size_t.sizeof))); + auto _ptr668 = _len668 ? cast(char*)(*(cast(void**)(arg0 + (64+4*size_t.sizeof)))) : null; + if (_len668) deallocate ~= cast()_ptr668; + auto _list669 = WitString(_ptr668[0.._len668]); + Option!(WitString) _option674 = void; + bool _isSome674 = (cast(uint)(*(cast(ubyte*)(arg0 + (64+7*size_t.sizeof))))) != 0; + if (_isSome674) { + auto _len672 = *(cast(size_t*)(arg0 + (64+9*size_t.sizeof))); + auto _ptr672 = _len672 ? cast(char*)(*(cast(void**)(arg0 + (64+8*size_t.sizeof)))) : null; + if (_len672) deallocate ~= cast()_ptr672; + auto _list673 = WitString(_ptr672[0.._len672]); + + _option674 = Option!(WitString).makeSome(_list673); + } else { + _option674 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.java_packets.common.TestInstanceBlockData _record675 = { + test: _option666, + size: _record667, + rotation: _list669, + ignoreEntities: (cast(uint)(*(cast(ubyte*)(arg0 + (64+6*size_t.sizeof))))) != 0, + status: cast(wit.pumpkin.plugin.java_packets.common.TestInstanceBlockStatus)(cast(uint)(*(cast(ubyte*)(arg0 + (65+6*size_t.sizeof))))), + errorMessage: _option674, + }; + wit.pumpkin.plugin.java_packets.common.STestInstanceBlockAction _record676 = { + pos: _tuple661, + action: cast(wit.pumpkin.plugin.java_packets.common.TestInstanceBlockAction)(cast(uint)(*(cast(ubyte*)(arg0 + 52)))), + data: _record675, + }; + auto _payload778 = _record676; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sTestInstanceBlockAction(_payload778); + break; + } + case _Tag698.sUpdateSign: { + auto _tuple678 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 40))), + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + ); + auto _len679 = *(cast(size_t*)(arg0 + (56+1*size_t.sizeof))); + auto _ptr679 = _len679 ? cast(char*)(*(cast(void**)(arg0 + 56))) : null; + if (_len679) deallocate ~= cast()_ptr679; + auto _list680 = WitString(_ptr679[0.._len679]); + auto _len681 = *(cast(size_t*)(arg0 + (56+3*size_t.sizeof))); + auto _ptr681 = _len681 ? cast(char*)(*(cast(void**)(arg0 + (56+2*size_t.sizeof)))) : null; + if (_len681) deallocate ~= cast()_ptr681; + auto _list682 = WitString(_ptr681[0.._len681]); + auto _len683 = *(cast(size_t*)(arg0 + (56+5*size_t.sizeof))); + auto _ptr683 = _len683 ? cast(char*)(*(cast(void**)(arg0 + (56+4*size_t.sizeof)))) : null; + if (_len683) deallocate ~= cast()_ptr683; + auto _list684 = WitString(_ptr683[0.._len683]); + auto _len685 = *(cast(size_t*)(arg0 + (56+7*size_t.sizeof))); + auto _ptr685 = _len685 ? cast(char*)(*(cast(void**)(arg0 + (56+6*size_t.sizeof)))) : null; + if (_len685) deallocate ~= cast()_ptr685; + auto _list686 = WitString(_ptr685[0.._len685]); + wit.pumpkin.plugin.java_packets.common.SUpdateSign _record687 = { + location: _tuple678, + isFrontText: (cast(uint)(*(cast(ubyte*)(arg0 + 52)))) != 0, + line1: _list680, + line2: _list682, + line3: _list684, + line4: _list686, + }; + auto _payload779 = _record687; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sUpdateSign(_payload779); + break; + } + case _Tag698.sUseItem: { + wit.pumpkin.plugin.java_packets.common.SUseItem _record689 = { + hand: cast(int)(*(cast(uint*)(arg0 + 40))), + sequence: cast(int)(*(cast(uint*)(arg0 + 44))), + yaw: *(cast(float*)(arg0 + 48)), + pitch: *(cast(float*)(arg0 + 52)), + }; + auto _payload780 = _record689; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sUseItem(_payload780); + break; + } + case _Tag698.sUseItemOn: { + auto _tuple691 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + cast(int)(*(cast(uint*)(arg0 + 52))), + ); + auto _tuple692 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 64)), + *(cast(double*)(arg0 + 72)), + *(cast(double*)(arg0 + 80)), + ); + wit.pumpkin.plugin.java_packets.common.SUseItemOn _record693 = { + hand: cast(int)(*(cast(uint*)(arg0 + 40))), + position: _tuple691, + face: cast(int)(*(cast(uint*)(arg0 + 56))), + cursorPos: _tuple692, + insideBlock: (cast(uint)(*(cast(ubyte*)(arg0 + 88)))) != 0, + isAgainstWorldBorder: (cast(uint)(*(cast(ubyte*)(arg0 + 89)))) != 0, + sequence: cast(int)(*(cast(uint*)(arg0 + 92))), + }; + auto _payload781 = _record693; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.sUseItemOn(_payload781); + break; + } + case _Tag698.statusSStatusPingRequest: { + wit.pumpkin.plugin.java_packets.common.StatusSStatusPingRequest _record695 = { + payload: cast(long)(*(cast(ulong*)(arg0 + 40))), + }; + auto _payload782 = _record695; + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.statusSStatusPingRequest(_payload782); + break; + } + case _Tag698.statusSStatusRequest: { + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.statusSStatusRequest(); + break; + } + case _Tag698.unknown: { + _variant698 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.unknown(); + break; + } + } + auto _payload1397 = _variant698; + _variant1396 = wit.pumpkin.plugin.event.common.ServerboundPacket.java(_payload1397); + break; + } + case _Tag1396.bedrock: { + wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket _variant1365 = void; + auto _tag1365 = cast(uint)(*(cast(ubyte*)(arg0 + 32))); + alias _Tag1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.Tag; + final switch (cast(wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.Tag)_tag1365) { + case _Tag1365.sActorEvent: { + Option!(Tuple!(double, double, double)) _option790 = void; + bool _isSome790 = (cast(uint)(*(cast(ubyte*)(arg0 + 56)))) != 0; + if (_isSome790) { + auto _tuple789 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 64)), + *(cast(double*)(arg0 + 72)), + *(cast(double*)(arg0 + 80)), + ); + + _option790 = Option!(Tuple!(double, double, double)).makeSome(_tuple789); + } else { + _option790 = Option!(Tuple!(double, double, double)).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.SActorEvent _record791 = { + targetRuntimeId: cast(long)(*(cast(ulong*)(arg0 + 40))), + eventId: cast(wit.pumpkin.plugin.bedrock_packets.common.ActorEventId)(cast(uint)(*(cast(ubyte*)(arg0 + 48)))), + data: cast(int)(*(cast(uint*)(arg0 + 52))), + fireAtPosition: _option790, + }; + auto _payload1366 = _record791; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sActorEvent(_payload1366); + break; + } + case _Tag1365.sAnimate: { + Option!(wit.pumpkin.plugin.bedrock_packets.common.ActorSwingSource) _option795 = void; + bool _isSome795 = (cast(uint)(*(cast(ubyte*)(arg0 + 60)))) != 0; + if (_isSome795) { + + _option795 = Option!(wit.pumpkin.plugin.bedrock_packets.common.ActorSwingSource).makeSome(cast(wit.pumpkin.plugin.bedrock_packets.common.ActorSwingSource)(cast(uint)(*(cast(ubyte*)(arg0 + 61))))); + } else { + _option795 = Option!(wit.pumpkin.plugin.bedrock_packets.common.ActorSwingSource).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.SAnimate _record796 = { + action: cast(wit.pumpkin.plugin.bedrock_packets.common.AnimateAction)(cast(uint)(*(cast(ubyte*)(arg0 + 40)))), + targetActorRuntimeId: cast(long)(*(cast(ulong*)(arg0 + 48))), + data: *(cast(float*)(arg0 + 56)), + swingSource: _option795, + }; + auto _payload1367 = _record796; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sAnimate(_payload1367); + break; + } + case _Tag1365.sBlockPickRequest: { + auto _tuple798 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 40))), + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + ); + wit.pumpkin.plugin.bedrock_packets.common.SBlockPickRequest _record799 = { + position: _tuple798, + withData: (cast(uint)(*(cast(ubyte*)(arg0 + 52)))) != 0, + maxSlots: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 53)))), + }; + auto _payload1368 = _record799; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sBlockPickRequest(_payload1368); + break; + } + case _Tag1365.sClientCacheBlobStatus: { + auto _len801 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr801 = _len801 ? cast(long*)(*(cast(void**)(arg0 + 40))) : null; + if (_len801) deallocate ~= cast()_ptr801; + auto _list802 = WitList!(long)(_ptr801[0.._len801]); + auto _len803 = *(cast(size_t*)(arg0 + (40+3*size_t.sizeof))); + auto _ptr803 = _len803 ? cast(long*)(*(cast(void**)(arg0 + (40+2*size_t.sizeof)))) : null; + if (_len803) deallocate ~= cast()_ptr803; + auto _list804 = WitList!(long)(_ptr803[0.._len803]); + wit.pumpkin.plugin.bedrock_packets.common.SClientCacheBlobStatus _record805 = { + missHashes: _list802, + hitHashes: _list804, + }; + auto _payload1369 = _record805; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sClientCacheBlobStatus(_payload1369); + break; + } + case _Tag1365.sClientCacheStatus: { + wit.pumpkin.plugin.bedrock_packets.common.SClientCacheStatus _record807 = { + isCacheSupported: (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0, + }; + auto _payload1370 = _record807; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sClientCacheStatus(_payload1370); + break; + } + case _Tag1365.sCommandRequest: { + auto _len809 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr809 = _len809 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len809) deallocate ~= cast()_ptr809; + auto _list810 = WitString(_ptr809[0.._len809]); + auto _len811 = *(cast(size_t*)(arg0 + (40+3*size_t.sizeof))); + auto _ptr811 = _len811 ? cast(char*)(*(cast(void**)(arg0 + (40+2*size_t.sizeof)))) : null; + if (_len811) deallocate ~= cast()_ptr811; + auto _list812 = WitString(_ptr811[0.._len811]); + wit.pumpkin.plugin.uuid.common.Uuid _record813 = { + high: *(cast(ulong*)(arg0 + (40+4*size_t.sizeof))), + low: *(cast(ulong*)(arg0 + (48+4*size_t.sizeof))), + }; + auto _len814 = *(cast(size_t*)(arg0 + (56+5*size_t.sizeof))); + auto _ptr814 = _len814 ? cast(char*)(*(cast(void**)(arg0 + (56+4*size_t.sizeof)))) : null; + if (_len814) deallocate ~= cast()_ptr814; + auto _list815 = WitString(_ptr814[0.._len814]); + wit.pumpkin.plugin.bedrock_packets.common.CommandOriginData _record816 = { + rType: _list812, + uuid: _record813, + requestId: _list815, + playerId: cast(long)(*(cast(ulong*)(arg0 + (56+6*size_t.sizeof)))), + }; + auto _len817 = *(cast(size_t*)(arg0 + (64+8*size_t.sizeof))); + auto _ptr817 = _len817 ? cast(char*)(*(cast(void**)(arg0 + (64+7*size_t.sizeof)))) : null; + if (_len817) deallocate ~= cast()_ptr817; + auto _list818 = WitString(_ptr817[0.._len817]); + wit.pumpkin.plugin.bedrock_packets.common.SCommandRequest _record819 = { + command: _list810, + origin: _record816, + isInternal: (cast(uint)(*(cast(ubyte*)(arg0 + (64+6*size_t.sizeof))))) != 0, + version_: _list818, + }; + auto _payload1371 = _record819; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sCommandRequest(_payload1371); + break; + } + case _Tag1365.sContainerClose: { + wit.pumpkin.plugin.bedrock_packets.common.SContainerClose _record821 = { + containerId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 40)))), + containerType: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 41)))), + serverInitiatedClose: (cast(uint)(*(cast(ubyte*)(arg0 + 42)))) != 0, + }; + auto _payload1372 = _record821; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sContainerClose(_payload1372); + break; + } + case _Tag1365.sEmote: { + auto _len823 = *(cast(size_t*)(arg0 + (48+1*size_t.sizeof))); + auto _ptr823 = _len823 ? cast(char*)(*(cast(void**)(arg0 + 48))) : null; + if (_len823) deallocate ~= cast()_ptr823; + auto _list824 = WitString(_ptr823[0.._len823]); + auto _len825 = *(cast(size_t*)(arg0 + (48+4*size_t.sizeof))); + auto _ptr825 = _len825 ? cast(char*)(*(cast(void**)(arg0 + (48+3*size_t.sizeof)))) : null; + if (_len825) deallocate ~= cast()_ptr825; + auto _list826 = WitString(_ptr825[0.._len825]); + auto _len827 = *(cast(size_t*)(arg0 + (48+6*size_t.sizeof))); + auto _ptr827 = _len827 ? cast(char*)(*(cast(void**)(arg0 + (48+5*size_t.sizeof)))) : null; + if (_len827) deallocate ~= cast()_ptr827; + auto _list828 = WitString(_ptr827[0.._len827]); + wit.pumpkin.plugin.bedrock_packets.common.SEmote _record829 = { + actorRuntimeId: cast(long)(*(cast(ulong*)(arg0 + 40))), + emoteId: _list824, + emoteLengthTicks: cast(int)(*(cast(uint*)(arg0 + (48+2*size_t.sizeof)))), + xuid: _list826, + platformId: _list828, + flags: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (48+7*size_t.sizeof))))), + }; + auto _payload1373 = _record829; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sEmote(_payload1373); + break; + } + case _Tag1365.sEmoteList: { + auto _len831 = *(cast(size_t*)(arg0 + (48+1*size_t.sizeof))); + auto _ptr831 = _len831 ? cast(wit.pumpkin.plugin.bedrock_packets.common.Uuid*)(*(cast(void**)(arg0 + 48))) : null; + if (_len831) deallocate ~= cast()_ptr831; + auto _list832 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.Uuid)(_ptr831[0.._len831]); + wit.pumpkin.plugin.bedrock_packets.common.SEmoteList _record833 = { + runtimeId: cast(long)(*(cast(ulong*)(arg0 + 40))), + emotePieceIds: _list832, + }; + auto _payload1374 = _record833; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sEmoteList(_payload1374); + break; + } + case _Tag1365.sInteract: { + Option!(Tuple!(double, double, double)) _option838 = void; + bool _isSome838 = (cast(uint)(*(cast(ubyte*)(arg0 + 56)))) != 0; + if (_isSome838) { + auto _tuple837 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 64)), + *(cast(double*)(arg0 + 72)), + *(cast(double*)(arg0 + 80)), + ); + + _option838 = Option!(Tuple!(double, double, double)).makeSome(_tuple837); + } else { + _option838 = Option!(Tuple!(double, double, double)).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.SInteract _record839 = { + action: cast(wit.pumpkin.plugin.bedrock_packets.common.Action)(cast(uint)(*(cast(ubyte*)(arg0 + 40)))), + targetRuntimeId: cast(long)(*(cast(ulong*)(arg0 + 48))), + position: _option838, + }; + auto _payload1375 = _record839; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sInteract(_payload1375); + break; + } + case _Tag1365.sInventoryTransaction: { + auto _listSrcPtr845 = *(cast(void**)(arg0 + (40+1*size_t.sizeof))); + auto _listLen845 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _list845 = _listLen845 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.LegacySetItemSlot)(_listLen845) : []; + assert(!_listLen845 || _list845.ptr); + if (_listLen845) deallocate ~= cast(void*)_list845.ptr; + foreach (_elem841_idx, ref _elem841; _list845) { + const auto _base841 = _listSrcPtr845 + _elem841_idx * (3*size_t.sizeof); + auto _len842 = *(cast(size_t*)(_base841 + (2*size_t.sizeof))); + auto _ptr842 = _len842 ? cast(ubyte*)(*(cast(void**)(_base841 + size_t.sizeof))) : null; + if (_len842) deallocate ~= cast()_ptr842; + auto _list843 = WitList!(ubyte)(_ptr842[0.._len842]); + wit.pumpkin.plugin.bedrock_packets.common.LegacySetItemSlot _record844 = { + containerId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base841 + 0)))), + slots: _list843, + }; + _elem841 = _record844; + } + if (_listLen845) deallocate ~= _listSrcPtr845; + auto _witList846 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.LegacySetItemSlot)(_list845); + auto _listSrcPtr881 = *(cast(void**)(arg0 + (40+4*size_t.sizeof))); + auto _listLen881 = *(cast(size_t*)(arg0 + (40+5*size_t.sizeof))); + auto _list881 = _listLen881 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.InventoryAction)(_listLen881) : []; + assert(!_listLen881 || _list881.ptr); + if (_listLen881) deallocate ~= cast(void*)_list881.ptr; + foreach (_elem847_idx, ref _elem847; _list881) { + const auto _base847 = _listSrcPtr881 + _elem847_idx * (72+12*size_t.sizeof); + Option!(int) _option850 = void; + bool _isSome850 = (cast(uint)(*(cast(ubyte*)(_base847 + 4)))) != 0; + if (_isSome850) { + + _option850 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base847 + 8)))); + } else { + _option850 = Option!(int).makeNone; + } + Option!(int) _option853 = void; + bool _isSome853 = (cast(uint)(*(cast(ubyte*)(_base847 + 12)))) != 0; + if (_isSome853) { + + _option853 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base847 + 16)))); + } else { + _option853 = Option!(int).makeNone; + } + auto _len854 = *(cast(size_t*)(_base847 + (40+1*size_t.sizeof))); + auto _ptr854 = _len854 ? cast(char*)(*(cast(void**)(_base847 + 40))) : null; + if (_len854) deallocate ~= cast()_ptr854; + auto _list855 = WitString(_ptr854[0.._len854]); + auto _listSrcPtr859 = *(cast(void**)(_base847 + (40+2*size_t.sizeof))); + auto _listLen859 = *(cast(size_t*)(_base847 + (40+3*size_t.sizeof))); + auto _list859 = _listLen859 ? wit.common.mallocSlice!(WitString)(_listLen859) : []; + assert(!_listLen859 || _list859.ptr); + if (_listLen859) deallocate ~= cast(void*)_list859.ptr; + foreach (_elem856_idx, ref _elem856; _list859) { + const auto _base856 = _listSrcPtr859 + _elem856_idx * (2*size_t.sizeof); + auto _len857 = *(cast(size_t*)(_base856 + size_t.sizeof)); + auto _ptr857 = _len857 ? cast(char*)(*(cast(void**)(_base856 + 0))) : null; + if (_len857) deallocate ~= cast()_ptr857; + auto _list858 = WitString(_ptr857[0.._len857]); + _elem856 = _list858; + } + if (_listLen859) deallocate ~= _listSrcPtr859; + auto _witList860 = WitList!(WitString)(_list859); + auto _listSrcPtr864 = *(cast(void**)(_base847 + (40+4*size_t.sizeof))); + auto _listLen864 = *(cast(size_t*)(_base847 + (40+5*size_t.sizeof))); + auto _list864 = _listLen864 ? wit.common.mallocSlice!(WitString)(_listLen864) : []; + assert(!_listLen864 || _list864.ptr); + if (_listLen864) deallocate ~= cast(void*)_list864.ptr; + foreach (_elem861_idx, ref _elem861; _list864) { + const auto _base861 = _listSrcPtr864 + _elem861_idx * (2*size_t.sizeof); + auto _len862 = *(cast(size_t*)(_base861 + size_t.sizeof)); + auto _ptr862 = _len862 ? cast(char*)(*(cast(void**)(_base861 + 0))) : null; + if (_len862) deallocate ~= cast()_ptr862; + auto _list863 = WitString(_ptr862[0.._len862]); + _elem861 = _list863; + } + if (_listLen864) deallocate ~= _listSrcPtr864; + auto _witList865 = WitList!(WitString)(_list864); + wit.pumpkin.plugin.bedrock_packets.common.NetworkItemDescriptor _record866 = { + id: cast(int)(*(cast(uint*)(_base847 + 24))), + stackSize: cast(int)(*(cast(uint*)(_base847 + 28))), + auxValue: cast(int)(*(cast(uint*)(_base847 + 32))), + blockRuntimeId: cast(int)(*(cast(uint*)(_base847 + 36))), + nbtData: _list855, + placeOnBlocks: _witList860, + destroyBlocks: _witList865, + shieldBlockingTick: cast(long)(*(cast(ulong*)(_base847 + (40+6*size_t.sizeof)))), + }; + auto _len867 = *(cast(size_t*)(_base847 + (64+7*size_t.sizeof))); + auto _ptr867 = _len867 ? cast(char*)(*(cast(void**)(_base847 + (64+6*size_t.sizeof)))) : null; + if (_len867) deallocate ~= cast()_ptr867; + auto _list868 = WitString(_ptr867[0.._len867]); + auto _listSrcPtr872 = *(cast(void**)(_base847 + (64+8*size_t.sizeof))); + auto _listLen872 = *(cast(size_t*)(_base847 + (64+9*size_t.sizeof))); + auto _list872 = _listLen872 ? wit.common.mallocSlice!(WitString)(_listLen872) : []; + assert(!_listLen872 || _list872.ptr); + if (_listLen872) deallocate ~= cast(void*)_list872.ptr; + foreach (_elem869_idx, ref _elem869; _list872) { + const auto _base869 = _listSrcPtr872 + _elem869_idx * (2*size_t.sizeof); + auto _len870 = *(cast(size_t*)(_base869 + size_t.sizeof)); + auto _ptr870 = _len870 ? cast(char*)(*(cast(void**)(_base869 + 0))) : null; + if (_len870) deallocate ~= cast()_ptr870; + auto _list871 = WitString(_ptr870[0.._len870]); + _elem869 = _list871; + } + if (_listLen872) deallocate ~= _listSrcPtr872; + auto _witList873 = WitList!(WitString)(_list872); + auto _listSrcPtr877 = *(cast(void**)(_base847 + (64+10*size_t.sizeof))); + auto _listLen877 = *(cast(size_t*)(_base847 + (64+11*size_t.sizeof))); + auto _list877 = _listLen877 ? wit.common.mallocSlice!(WitString)(_listLen877) : []; + assert(!_listLen877 || _list877.ptr); + if (_listLen877) deallocate ~= cast(void*)_list877.ptr; + foreach (_elem874_idx, ref _elem874; _list877) { + const auto _base874 = _listSrcPtr877 + _elem874_idx * (2*size_t.sizeof); + auto _len875 = *(cast(size_t*)(_base874 + size_t.sizeof)); + auto _ptr875 = _len875 ? cast(char*)(*(cast(void**)(_base874 + 0))) : null; + if (_len875) deallocate ~= cast()_ptr875; + auto _list876 = WitString(_ptr875[0.._len875]); + _elem874 = _list876; + } + if (_listLen877) deallocate ~= _listSrcPtr877; + auto _witList878 = WitList!(WitString)(_list877); + wit.pumpkin.plugin.bedrock_packets.common.NetworkItemDescriptor _record879 = { + id: cast(int)(*(cast(uint*)(_base847 + (48+6*size_t.sizeof)))), + stackSize: cast(int)(*(cast(uint*)(_base847 + (52+6*size_t.sizeof)))), + auxValue: cast(int)(*(cast(uint*)(_base847 + (56+6*size_t.sizeof)))), + blockRuntimeId: cast(int)(*(cast(uint*)(_base847 + (60+6*size_t.sizeof)))), + nbtData: _list868, + placeOnBlocks: _witList873, + destroyBlocks: _witList878, + shieldBlockingTick: cast(long)(*(cast(ulong*)(_base847 + (64+12*size_t.sizeof)))), + }; + wit.pumpkin.plugin.bedrock_packets.common.InventoryAction _record880 = { + sourceType: cast(int)(*(cast(uint*)(_base847 + 0))), + windowId: _option850, + sourceFlags: _option853, + inventorySlot: cast(int)(*(cast(uint*)(_base847 + 20))), + oldItem: _record866, + newItem: _record879, + }; + _elem847 = _record880; + } + if (_listLen881) deallocate ~= _listSrcPtr881; + auto _witList882 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.InventoryAction)(_list881); + wit.pumpkin.plugin.bedrock_packets.common.TransactionData _variant940 = void; + auto _tag940 = cast(uint)(*(cast(ubyte*)(arg0 + (48+6*size_t.sizeof)))); + alias _Tag940 = wit.pumpkin.plugin.bedrock_packets.common.TransactionData.Tag; + final switch (cast(wit.pumpkin.plugin.bedrock_packets.common.TransactionData.Tag)_tag940) { + case _Tag940.normal: { + auto _len884 = *(cast(size_t*)(arg0 + (56+7*size_t.sizeof))); + auto _ptr884 = _len884 ? cast(char*)(*(cast(void**)(arg0 + (56+6*size_t.sizeof)))) : null; + if (_len884) deallocate ~= cast()_ptr884; + auto _list885 = WitString(_ptr884[0.._len884]); + auto _payload941 = _list885; + _variant940 = wit.pumpkin.plugin.bedrock_packets.common.TransactionData.normal(_payload941); + break; + } + case _Tag940.mismatch: { + auto _len887 = *(cast(size_t*)(arg0 + (56+7*size_t.sizeof))); + auto _ptr887 = _len887 ? cast(char*)(*(cast(void**)(arg0 + (56+6*size_t.sizeof)))) : null; + if (_len887) deallocate ~= cast()_ptr887; + auto _list888 = WitString(_ptr887[0.._len887]); + auto _payload942 = _list888; + _variant940 = wit.pumpkin.plugin.bedrock_packets.common.TransactionData.mismatch(_payload942); + break; + } + case _Tag940.useItem: { + auto _tuple890 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + (64+6*size_t.sizeof)))), + cast(int)(*(cast(uint*)(arg0 + (68+6*size_t.sizeof)))), + cast(int)(*(cast(uint*)(arg0 + (72+6*size_t.sizeof)))), + ); + auto _len891 = *(cast(size_t*)(arg0 + (104+7*size_t.sizeof))); + auto _ptr891 = _len891 ? cast(char*)(*(cast(void**)(arg0 + (104+6*size_t.sizeof)))) : null; + if (_len891) deallocate ~= cast()_ptr891; + auto _list892 = WitString(_ptr891[0.._len891]); + auto _listSrcPtr896 = *(cast(void**)(arg0 + (104+8*size_t.sizeof))); + auto _listLen896 = *(cast(size_t*)(arg0 + (104+9*size_t.sizeof))); + auto _list896 = _listLen896 ? wit.common.mallocSlice!(WitString)(_listLen896) : []; + assert(!_listLen896 || _list896.ptr); + if (_listLen896) deallocate ~= cast(void*)_list896.ptr; + foreach (_elem893_idx, ref _elem893; _list896) { + const auto _base893 = _listSrcPtr896 + _elem893_idx * (2*size_t.sizeof); + auto _len894 = *(cast(size_t*)(_base893 + size_t.sizeof)); + auto _ptr894 = _len894 ? cast(char*)(*(cast(void**)(_base893 + 0))) : null; + if (_len894) deallocate ~= cast()_ptr894; + auto _list895 = WitString(_ptr894[0.._len894]); + _elem893 = _list895; + } + if (_listLen896) deallocate ~= _listSrcPtr896; + auto _witList897 = WitList!(WitString)(_list896); + auto _listSrcPtr901 = *(cast(void**)(arg0 + (104+10*size_t.sizeof))); + auto _listLen901 = *(cast(size_t*)(arg0 + (104+11*size_t.sizeof))); + auto _list901 = _listLen901 ? wit.common.mallocSlice!(WitString)(_listLen901) : []; + assert(!_listLen901 || _list901.ptr); + if (_listLen901) deallocate ~= cast(void*)_list901.ptr; + foreach (_elem898_idx, ref _elem898; _list901) { + const auto _base898 = _listSrcPtr901 + _elem898_idx * (2*size_t.sizeof); + auto _len899 = *(cast(size_t*)(_base898 + size_t.sizeof)); + auto _ptr899 = _len899 ? cast(char*)(*(cast(void**)(_base898 + 0))) : null; + if (_len899) deallocate ~= cast()_ptr899; + auto _list900 = WitString(_ptr899[0.._len899]); + _elem898 = _list900; + } + if (_listLen901) deallocate ~= _listSrcPtr901; + auto _witList902 = WitList!(WitString)(_list901); + wit.pumpkin.plugin.bedrock_packets.common.NetworkItemDescriptor _record903 = { + id: cast(int)(*(cast(uint*)(arg0 + (88+6*size_t.sizeof)))), + stackSize: cast(int)(*(cast(uint*)(arg0 + (92+6*size_t.sizeof)))), + auxValue: cast(int)(*(cast(uint*)(arg0 + (96+6*size_t.sizeof)))), + blockRuntimeId: cast(int)(*(cast(uint*)(arg0 + (100+6*size_t.sizeof)))), + nbtData: _list892, + placeOnBlocks: _witList897, + destroyBlocks: _witList902, + shieldBlockingTick: cast(long)(*(cast(ulong*)(arg0 + (104+12*size_t.sizeof)))), + }; + auto _tuple904 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + (112+12*size_t.sizeof))), + *(cast(double*)(arg0 + (120+12*size_t.sizeof))), + *(cast(double*)(arg0 + (128+12*size_t.sizeof))), + ); + auto _tuple905 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + (136+12*size_t.sizeof))), + *(cast(double*)(arg0 + (144+12*size_t.sizeof))), + *(cast(double*)(arg0 + (152+12*size_t.sizeof))), + ); + wit.pumpkin.plugin.bedrock_packets.common.UseItemTransactionData _record906 = { + actionType: cast(int)(*(cast(uint*)(arg0 + (56+6*size_t.sizeof)))), + triggerType: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (60+6*size_t.sizeof))))), + blockPosition: _tuple890, + blockFace: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (76+6*size_t.sizeof))))), + hotBarSlot: cast(int)(*(cast(uint*)(arg0 + (80+6*size_t.sizeof)))), + itemInHand: _record903, + playerPosition: _tuple904, + clickPosition: _tuple905, + blockRuntimeId: cast(int)(*(cast(uint*)(arg0 + (160+12*size_t.sizeof)))), + clientPrediction: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (164+12*size_t.sizeof))))), + clientCooldownState: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (165+12*size_t.sizeof))))), + }; + auto _payload943 = _record906; + _variant940 = wit.pumpkin.plugin.bedrock_packets.common.TransactionData.useItem(_payload943); + break; + } + case _Tag940.useItemOnEntity: { + auto _len908 = *(cast(size_t*)(arg0 + (88+7*size_t.sizeof))); + auto _ptr908 = _len908 ? cast(char*)(*(cast(void**)(arg0 + (88+6*size_t.sizeof)))) : null; + if (_len908) deallocate ~= cast()_ptr908; + auto _list909 = WitString(_ptr908[0.._len908]); + auto _listSrcPtr913 = *(cast(void**)(arg0 + (88+8*size_t.sizeof))); + auto _listLen913 = *(cast(size_t*)(arg0 + (88+9*size_t.sizeof))); + auto _list913 = _listLen913 ? wit.common.mallocSlice!(WitString)(_listLen913) : []; + assert(!_listLen913 || _list913.ptr); + if (_listLen913) deallocate ~= cast(void*)_list913.ptr; + foreach (_elem910_idx, ref _elem910; _list913) { + const auto _base910 = _listSrcPtr913 + _elem910_idx * (2*size_t.sizeof); + auto _len911 = *(cast(size_t*)(_base910 + size_t.sizeof)); + auto _ptr911 = _len911 ? cast(char*)(*(cast(void**)(_base910 + 0))) : null; + if (_len911) deallocate ~= cast()_ptr911; + auto _list912 = WitString(_ptr911[0.._len911]); + _elem910 = _list912; + } + if (_listLen913) deallocate ~= _listSrcPtr913; + auto _witList914 = WitList!(WitString)(_list913); + auto _listSrcPtr918 = *(cast(void**)(arg0 + (88+10*size_t.sizeof))); + auto _listLen918 = *(cast(size_t*)(arg0 + (88+11*size_t.sizeof))); + auto _list918 = _listLen918 ? wit.common.mallocSlice!(WitString)(_listLen918) : []; + assert(!_listLen918 || _list918.ptr); + if (_listLen918) deallocate ~= cast(void*)_list918.ptr; + foreach (_elem915_idx, ref _elem915; _list918) { + const auto _base915 = _listSrcPtr918 + _elem915_idx * (2*size_t.sizeof); + auto _len916 = *(cast(size_t*)(_base915 + size_t.sizeof)); + auto _ptr916 = _len916 ? cast(char*)(*(cast(void**)(_base915 + 0))) : null; + if (_len916) deallocate ~= cast()_ptr916; + auto _list917 = WitString(_ptr916[0.._len916]); + _elem915 = _list917; + } + if (_listLen918) deallocate ~= _listSrcPtr918; + auto _witList919 = WitList!(WitString)(_list918); + wit.pumpkin.plugin.bedrock_packets.common.NetworkItemDescriptor _record920 = { + id: cast(int)(*(cast(uint*)(arg0 + (72+6*size_t.sizeof)))), + stackSize: cast(int)(*(cast(uint*)(arg0 + (76+6*size_t.sizeof)))), + auxValue: cast(int)(*(cast(uint*)(arg0 + (80+6*size_t.sizeof)))), + blockRuntimeId: cast(int)(*(cast(uint*)(arg0 + (84+6*size_t.sizeof)))), + nbtData: _list909, + placeOnBlocks: _witList914, + destroyBlocks: _witList919, + shieldBlockingTick: cast(long)(*(cast(ulong*)(arg0 + (88+12*size_t.sizeof)))), + }; + auto _tuple921 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + (96+12*size_t.sizeof))), + *(cast(double*)(arg0 + (104+12*size_t.sizeof))), + *(cast(double*)(arg0 + (112+12*size_t.sizeof))), + ); + auto _tuple922 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + (120+12*size_t.sizeof))), + *(cast(double*)(arg0 + (128+12*size_t.sizeof))), + *(cast(double*)(arg0 + (136+12*size_t.sizeof))), + ); + wit.pumpkin.plugin.bedrock_packets.common.UseItemOnEntityTransactionData _record923 = { + targetEntityRuntimeId: cast(long)(*(cast(ulong*)(arg0 + (56+6*size_t.sizeof)))), + actionType: cast(int)(*(cast(uint*)(arg0 + (64+6*size_t.sizeof)))), + hotBarSlot: cast(int)(*(cast(uint*)(arg0 + (68+6*size_t.sizeof)))), + itemInHand: _record920, + playerPosition: _tuple921, + clickPosition: _tuple922, + }; + auto _payload944 = _record923; + _variant940 = wit.pumpkin.plugin.bedrock_packets.common.TransactionData.useItemOnEntity(_payload944); + break; + } + case _Tag940.releaseItem: { + auto _len925 = *(cast(size_t*)(arg0 + (80+7*size_t.sizeof))); + auto _ptr925 = _len925 ? cast(char*)(*(cast(void**)(arg0 + (80+6*size_t.sizeof)))) : null; + if (_len925) deallocate ~= cast()_ptr925; + auto _list926 = WitString(_ptr925[0.._len925]); + auto _listSrcPtr930 = *(cast(void**)(arg0 + (80+8*size_t.sizeof))); + auto _listLen930 = *(cast(size_t*)(arg0 + (80+9*size_t.sizeof))); + auto _list930 = _listLen930 ? wit.common.mallocSlice!(WitString)(_listLen930) : []; + assert(!_listLen930 || _list930.ptr); + if (_listLen930) deallocate ~= cast(void*)_list930.ptr; + foreach (_elem927_idx, ref _elem927; _list930) { + const auto _base927 = _listSrcPtr930 + _elem927_idx * (2*size_t.sizeof); + auto _len928 = *(cast(size_t*)(_base927 + size_t.sizeof)); + auto _ptr928 = _len928 ? cast(char*)(*(cast(void**)(_base927 + 0))) : null; + if (_len928) deallocate ~= cast()_ptr928; + auto _list929 = WitString(_ptr928[0.._len928]); + _elem927 = _list929; + } + if (_listLen930) deallocate ~= _listSrcPtr930; + auto _witList931 = WitList!(WitString)(_list930); + auto _listSrcPtr935 = *(cast(void**)(arg0 + (80+10*size_t.sizeof))); + auto _listLen935 = *(cast(size_t*)(arg0 + (80+11*size_t.sizeof))); + auto _list935 = _listLen935 ? wit.common.mallocSlice!(WitString)(_listLen935) : []; + assert(!_listLen935 || _list935.ptr); + if (_listLen935) deallocate ~= cast(void*)_list935.ptr; + foreach (_elem932_idx, ref _elem932; _list935) { + const auto _base932 = _listSrcPtr935 + _elem932_idx * (2*size_t.sizeof); + auto _len933 = *(cast(size_t*)(_base932 + size_t.sizeof)); + auto _ptr933 = _len933 ? cast(char*)(*(cast(void**)(_base932 + 0))) : null; + if (_len933) deallocate ~= cast()_ptr933; + auto _list934 = WitString(_ptr933[0.._len933]); + _elem932 = _list934; + } + if (_listLen935) deallocate ~= _listSrcPtr935; + auto _witList936 = WitList!(WitString)(_list935); + wit.pumpkin.plugin.bedrock_packets.common.NetworkItemDescriptor _record937 = { + id: cast(int)(*(cast(uint*)(arg0 + (64+6*size_t.sizeof)))), + stackSize: cast(int)(*(cast(uint*)(arg0 + (68+6*size_t.sizeof)))), + auxValue: cast(int)(*(cast(uint*)(arg0 + (72+6*size_t.sizeof)))), + blockRuntimeId: cast(int)(*(cast(uint*)(arg0 + (76+6*size_t.sizeof)))), + nbtData: _list926, + placeOnBlocks: _witList931, + destroyBlocks: _witList936, + shieldBlockingTick: cast(long)(*(cast(ulong*)(arg0 + (80+12*size_t.sizeof)))), + }; + auto _tuple938 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + (88+12*size_t.sizeof))), + *(cast(double*)(arg0 + (96+12*size_t.sizeof))), + *(cast(double*)(arg0 + (104+12*size_t.sizeof))), + ); + wit.pumpkin.plugin.bedrock_packets.common.ReleaseItemTransactionData _record939 = { + actionType: cast(int)(*(cast(uint*)(arg0 + (56+6*size_t.sizeof)))), + hotBarSlot: cast(int)(*(cast(uint*)(arg0 + (60+6*size_t.sizeof)))), + itemInHand: _record937, + headPosition: _tuple938, + }; + auto _payload945 = _record939; + _variant940 = wit.pumpkin.plugin.bedrock_packets.common.TransactionData.releaseItem(_payload945); + break; + } + } + wit.pumpkin.plugin.bedrock_packets.common.SInventoryTransaction _record946 = { + legacyRequestId: cast(int)(*(cast(uint*)(arg0 + 40))), + legacySetItemSlots: _witList846, + hasValue: (cast(uint)(*(cast(ubyte*)(arg0 + (40+3*size_t.sizeof))))) != 0, + actions: _witList882, + transactionType: cast(int)(*(cast(uint*)(arg0 + (40+6*size_t.sizeof)))), + transactionData: _variant940, + }; + auto _payload1376 = _record946; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sInventoryTransaction(_payload1376); + break; + } + case _Tag1365.sItemStackRequest: { + auto _listSrcPtr1069 = *(cast(void**)(arg0 + 40)); + auto _listLen1069 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _list1069 = _listLen1069 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequest)(_listLen1069) : []; + assert(!_listLen1069 || _list1069.ptr); + if (_listLen1069) deallocate ~= cast(void*)_list1069.ptr; + foreach (_elem948_idx, ref _elem948; _list1069) { + const auto _base948 = _listSrcPtr1069 + _elem948_idx * (6*size_t.sizeof); + auto _listSrcPtr1061 = *(cast(void**)(_base948 + size_t.sizeof)); + auto _listLen1061 = *(cast(size_t*)(_base948 + (2*size_t.sizeof))); + auto _list1061 = _listLen1061 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction)(_listLen1061) : []; + assert(!_listLen1061 || _list1061.ptr); + if (_listLen1061) deallocate ~= cast(void*)_list1061.ptr; + foreach (_elem949_idx, ref _elem949; _list1061) { + const auto _base949 = _listSrcPtr1061 + _elem949_idx * (40+2*size_t.sizeof); + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction _variant1042 = void; + auto _tag1042 = cast(uint)(*(cast(ubyte*)(_base949 + 0))); + alias _Tag1042 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.Tag; + final switch (cast(wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.Tag)_tag1042) { + case _Tag1042.take: { + Option!(int) _option953 = void; + bool _isSome953 = (cast(uint)(*(cast(ubyte*)(_base949 + (8+1*size_t.sizeof))))) != 0; + if (_isSome953) { + + _option953 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base949 + (12+1*size_t.sizeof))))); + } else { + _option953 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.FullContainerName _record954 = { + containerName: cast(wit.pumpkin.plugin.bedrock_packets.common.ContainerName)(cast(uint)(*(cast(ubyte*)(_base949 + (4+1*size_t.sizeof))))), + dynamicId: _option953, + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestSlotInfo _record955 = { + containerName: _record954, + slotId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base949 + (16+1*size_t.sizeof))))), + stackId: cast(int)(*(cast(uint*)(_base949 + (20+1*size_t.sizeof)))), + }; + Option!(int) _option958 = void; + bool _isSome958 = (cast(uint)(*(cast(ubyte*)(_base949 + (28+1*size_t.sizeof))))) != 0; + if (_isSome958) { + + _option958 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base949 + (32+1*size_t.sizeof))))); + } else { + _option958 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.FullContainerName _record959 = { + containerName: cast(wit.pumpkin.plugin.bedrock_packets.common.ContainerName)(cast(uint)(*(cast(ubyte*)(_base949 + (24+1*size_t.sizeof))))), + dynamicId: _option958, + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestSlotInfo _record960 = { + containerName: _record959, + slotId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base949 + (36+1*size_t.sizeof))))), + stackId: cast(int)(*(cast(uint*)(_base949 + (40+1*size_t.sizeof)))), + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionTake _record961 = { + count: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base949 + size_t.sizeof)))), + source: _record955, + destination: _record960, + }; + auto _payload1043 = _record961; + _variant1042 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.take(_payload1043); + break; + } + case _Tag1042.place: { + Option!(int) _option965 = void; + bool _isSome965 = (cast(uint)(*(cast(ubyte*)(_base949 + (8+1*size_t.sizeof))))) != 0; + if (_isSome965) { + + _option965 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base949 + (12+1*size_t.sizeof))))); + } else { + _option965 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.FullContainerName _record966 = { + containerName: cast(wit.pumpkin.plugin.bedrock_packets.common.ContainerName)(cast(uint)(*(cast(ubyte*)(_base949 + (4+1*size_t.sizeof))))), + dynamicId: _option965, + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestSlotInfo _record967 = { + containerName: _record966, + slotId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base949 + (16+1*size_t.sizeof))))), + stackId: cast(int)(*(cast(uint*)(_base949 + (20+1*size_t.sizeof)))), + }; + Option!(int) _option970 = void; + bool _isSome970 = (cast(uint)(*(cast(ubyte*)(_base949 + (28+1*size_t.sizeof))))) != 0; + if (_isSome970) { + + _option970 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base949 + (32+1*size_t.sizeof))))); + } else { + _option970 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.FullContainerName _record971 = { + containerName: cast(wit.pumpkin.plugin.bedrock_packets.common.ContainerName)(cast(uint)(*(cast(ubyte*)(_base949 + (24+1*size_t.sizeof))))), + dynamicId: _option970, + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestSlotInfo _record972 = { + containerName: _record971, + slotId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base949 + (36+1*size_t.sizeof))))), + stackId: cast(int)(*(cast(uint*)(_base949 + (40+1*size_t.sizeof)))), + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionPlace _record973 = { + count: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base949 + size_t.sizeof)))), + source: _record967, + destination: _record972, + }; + auto _payload1044 = _record973; + _variant1042 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.place(_payload1044); + break; + } + case _Tag1042.swap: { + Option!(int) _option977 = void; + bool _isSome977 = (cast(uint)(*(cast(ubyte*)(_base949 + (4+1*size_t.sizeof))))) != 0; + if (_isSome977) { + + _option977 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base949 + (8+1*size_t.sizeof))))); + } else { + _option977 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.FullContainerName _record978 = { + containerName: cast(wit.pumpkin.plugin.bedrock_packets.common.ContainerName)(cast(uint)(*(cast(ubyte*)(_base949 + size_t.sizeof)))), + dynamicId: _option977, + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestSlotInfo _record979 = { + containerName: _record978, + slotId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base949 + (12+1*size_t.sizeof))))), + stackId: cast(int)(*(cast(uint*)(_base949 + (16+1*size_t.sizeof)))), + }; + Option!(int) _option982 = void; + bool _isSome982 = (cast(uint)(*(cast(ubyte*)(_base949 + (24+1*size_t.sizeof))))) != 0; + if (_isSome982) { + + _option982 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base949 + (28+1*size_t.sizeof))))); + } else { + _option982 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.FullContainerName _record983 = { + containerName: cast(wit.pumpkin.plugin.bedrock_packets.common.ContainerName)(cast(uint)(*(cast(ubyte*)(_base949 + (20+1*size_t.sizeof))))), + dynamicId: _option982, + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestSlotInfo _record984 = { + containerName: _record983, + slotId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base949 + (32+1*size_t.sizeof))))), + stackId: cast(int)(*(cast(uint*)(_base949 + (36+1*size_t.sizeof)))), + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionSwap _record985 = { + slot1: _record979, + slot2: _record984, + }; + auto _payload1045 = _record985; + _variant1042 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.swap(_payload1045); + break; + } + case _Tag1042.drop: { + Option!(int) _option989 = void; + bool _isSome989 = (cast(uint)(*(cast(ubyte*)(_base949 + (8+1*size_t.sizeof))))) != 0; + if (_isSome989) { + + _option989 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base949 + (12+1*size_t.sizeof))))); + } else { + _option989 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.FullContainerName _record990 = { + containerName: cast(wit.pumpkin.plugin.bedrock_packets.common.ContainerName)(cast(uint)(*(cast(ubyte*)(_base949 + (4+1*size_t.sizeof))))), + dynamicId: _option989, + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestSlotInfo _record991 = { + containerName: _record990, + slotId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base949 + (16+1*size_t.sizeof))))), + stackId: cast(int)(*(cast(uint*)(_base949 + (20+1*size_t.sizeof)))), + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionDrop _record992 = { + count: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base949 + size_t.sizeof)))), + source: _record991, + randomly: (cast(uint)(*(cast(ubyte*)(_base949 + (24+1*size_t.sizeof))))) != 0, + }; + auto _payload1046 = _record992; + _variant1042 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.drop(_payload1046); + break; + } + case _Tag1042.destroy: { + Option!(int) _option996 = void; + bool _isSome996 = (cast(uint)(*(cast(ubyte*)(_base949 + (8+1*size_t.sizeof))))) != 0; + if (_isSome996) { + + _option996 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base949 + (12+1*size_t.sizeof))))); + } else { + _option996 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.FullContainerName _record997 = { + containerName: cast(wit.pumpkin.plugin.bedrock_packets.common.ContainerName)(cast(uint)(*(cast(ubyte*)(_base949 + (4+1*size_t.sizeof))))), + dynamicId: _option996, + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestSlotInfo _record998 = { + containerName: _record997, + slotId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base949 + (16+1*size_t.sizeof))))), + stackId: cast(int)(*(cast(uint*)(_base949 + (20+1*size_t.sizeof)))), + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionDestroy _record999 = { + count: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base949 + size_t.sizeof)))), + source: _record998, + }; + auto _payload1047 = _record999; + _variant1042 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.destroy(_payload1047); + break; + } + case _Tag1042.consume: { + Option!(int) _option1003 = void; + bool _isSome1003 = (cast(uint)(*(cast(ubyte*)(_base949 + (8+1*size_t.sizeof))))) != 0; + if (_isSome1003) { + + _option1003 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base949 + (12+1*size_t.sizeof))))); + } else { + _option1003 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.FullContainerName _record1004 = { + containerName: cast(wit.pumpkin.plugin.bedrock_packets.common.ContainerName)(cast(uint)(*(cast(ubyte*)(_base949 + (4+1*size_t.sizeof))))), + dynamicId: _option1003, + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestSlotInfo _record1005 = { + containerName: _record1004, + slotId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base949 + (16+1*size_t.sizeof))))), + stackId: cast(int)(*(cast(uint*)(_base949 + (20+1*size_t.sizeof)))), + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionConsume _record1006 = { + count: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base949 + size_t.sizeof)))), + source: _record1005, + }; + auto _payload1048 = _record1006; + _variant1042 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.consume(_payload1048); + break; + } + case _Tag1042.create: { + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionCreate _record1008 = { + resultIndex: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base949 + size_t.sizeof)))), + }; + auto _payload1049 = _record1008; + _variant1042 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.create(_payload1049); + break; + } + case _Tag1042.labTableCombine: { + _variant1042 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.labTableCombine(); + break; + } + case _Tag1042.beaconPayment: { + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionBeaconPayment _record1011 = { + primaryEffectId: cast(int)(*(cast(uint*)(_base949 + size_t.sizeof))), + secondaryEffectId: cast(int)(*(cast(uint*)(_base949 + (4+1*size_t.sizeof)))), + }; + auto _payload1051 = _record1011; + _variant1042 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.beaconPayment(_payload1051); + break; + } + case _Tag1042.mineBlock: { + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionMineBlock _record1013 = { + hotbarSlot: cast(int)(*(cast(uint*)(_base949 + size_t.sizeof))), + predictedDurability: cast(int)(*(cast(uint*)(_base949 + (4+1*size_t.sizeof)))), + stackId: cast(int)(*(cast(uint*)(_base949 + (8+1*size_t.sizeof)))), + }; + auto _payload1052 = _record1013; + _variant1042 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.mineBlock(_payload1052); + break; + } + case _Tag1042.craftRecipe: { + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionCraftRecipe _record1015 = { + recipeId: cast(int)(*(cast(uint*)(_base949 + size_t.sizeof))), + repetitions: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base949 + (4+1*size_t.sizeof))))), + }; + auto _payload1053 = _record1015; + _variant1042 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.craftRecipe(_payload1053); + break; + } + case _Tag1042.craftRecipeAuto: { + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionCraftRecipeAuto _record1017 = { + recipeId: cast(int)(*(cast(uint*)(_base949 + size_t.sizeof))), + repetitions: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base949 + (4+1*size_t.sizeof))))), + }; + auto _payload1054 = _record1017; + _variant1042 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.craftRecipeAuto(_payload1054); + break; + } + case _Tag1042.craftCreative: { + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionCraftCreative _record1019 = { + creativeItemId: cast(int)(*(cast(uint*)(_base949 + size_t.sizeof))), + repetitions: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base949 + (4+1*size_t.sizeof))))), + }; + auto _payload1055 = _record1019; + _variant1042 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.craftCreative(_payload1055); + break; + } + case _Tag1042.optional: { + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionOptional _record1021 = { + recipeId: cast(int)(*(cast(uint*)(_base949 + size_t.sizeof))), + filterStringIndex: cast(int)(*(cast(uint*)(_base949 + (4+1*size_t.sizeof)))), + }; + auto _payload1056 = _record1021; + _variant1042 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.optional(_payload1056); + break; + } + case _Tag1042.grindstone: { + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionGrindstone _record1023 = { + recipeId: cast(int)(*(cast(uint*)(_base949 + size_t.sizeof))), + repairCost: cast(int)(*(cast(uint*)(_base949 + (4+1*size_t.sizeof)))), + repetitions: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base949 + (8+1*size_t.sizeof))))), + }; + auto _payload1057 = _record1023; + _variant1042 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.grindstone(_payload1057); + break; + } + case _Tag1042.loom: { + auto _len1025 = *(cast(size_t*)(_base949 + (2*size_t.sizeof))); + auto _ptr1025 = _len1025 ? cast(char*)(*(cast(void**)(_base949 + size_t.sizeof))) : null; + if (_len1025) deallocate ~= cast()_ptr1025; + auto _list1026 = WitString(_ptr1025[0.._len1025]); + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionLoom _record1027 = { + patternId: _list1026, + repetitions: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base949 + (3*size_t.sizeof))))), + }; + auto _payload1058 = _record1027; + _variant1042 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.loom(_payload1058); + break; + } + case _Tag1042.craftNonImplemented: { + _variant1042 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.craftNonImplemented(); + break; + } + case _Tag1042.craftResultsDeprecated: { + auto _listSrcPtr1039 = *(cast(void**)(_base949 + size_t.sizeof)); + auto _listLen1039 = *(cast(size_t*)(_base949 + (2*size_t.sizeof))); + auto _list1039 = _listLen1039 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.StackRequestItem)(_listLen1039) : []; + assert(!_listLen1039 || _list1039.ptr); + if (_listLen1039) deallocate ~= cast(void*)_list1039.ptr; + foreach (_elem1030_idx, ref _elem1030; _list1039) { + const auto _base1030 = _listSrcPtr1039 + _elem1030_idx * (8+6*size_t.sizeof); + Option!(WitString) _option1035 = void; + bool _isSome1035 = (cast(uint)(*(cast(ubyte*)(_base1030 + 0)))) != 0; + if (_isSome1035) { + auto _len1033 = *(cast(size_t*)(_base1030 + (2*size_t.sizeof))); + auto _ptr1033 = _len1033 ? cast(char*)(*(cast(void**)(_base1030 + size_t.sizeof))) : null; + if (_len1033) deallocate ~= cast()_ptr1033; + auto _list1034 = WitString(_ptr1033[0.._len1033]); + + _option1035 = Option!(WitString).makeSome(_list1034); + } else { + _option1035 = Option!(WitString).makeNone; + } + auto _len1036 = *(cast(size_t*)(_base1030 + (8+5*size_t.sizeof))); + auto _ptr1036 = _len1036 ? cast(ubyte*)(*(cast(void**)(_base1030 + (8+4*size_t.sizeof)))) : null; + if (_len1036) deallocate ~= cast()_ptr1036; + auto _list1037 = WitList!(ubyte)(_ptr1036[0.._len1036]); + wit.pumpkin.plugin.bedrock_packets.common.StackRequestItem _record1038 = { + identifier: _option1035, + metadataValue: cast(int)(*(cast(uint*)(_base1030 + (3*size_t.sizeof)))), + count: cast(int)(*(cast(uint*)(_base1030 + (4+3*size_t.sizeof)))), + blockRuntimeId: cast(int)(*(cast(uint*)(_base1030 + (8+3*size_t.sizeof)))), + extraData: _list1037, + }; + _elem1030 = _record1038; + } + if (_listLen1039) deallocate ~= _listSrcPtr1039; + auto _witList1040 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.StackRequestItem)(_list1039); + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionCraftResultsDeprecated _record1041 = { + resultItems: _witList1040, + timesCrafted: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base949 + (3*size_t.sizeof))))), + }; + auto _payload1060 = _record1041; + _variant1042 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.craftResultsDeprecated(_payload1060); + break; + } + } + _elem949 = _variant1042; + } + if (_listLen1061) deallocate ~= _listSrcPtr1061; + auto _witList1062 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction)(_list1061); + auto _listSrcPtr1066 = *(cast(void**)(_base948 + (3*size_t.sizeof))); + auto _listLen1066 = *(cast(size_t*)(_base948 + (4*size_t.sizeof))); + auto _list1066 = _listLen1066 ? wit.common.mallocSlice!(WitString)(_listLen1066) : []; + assert(!_listLen1066 || _list1066.ptr); + if (_listLen1066) deallocate ~= cast(void*)_list1066.ptr; + foreach (_elem1063_idx, ref _elem1063; _list1066) { + const auto _base1063 = _listSrcPtr1066 + _elem1063_idx * (2*size_t.sizeof); + auto _len1064 = *(cast(size_t*)(_base1063 + size_t.sizeof)); + auto _ptr1064 = _len1064 ? cast(char*)(*(cast(void**)(_base1063 + 0))) : null; + if (_len1064) deallocate ~= cast()_ptr1064; + auto _list1065 = WitString(_ptr1064[0.._len1064]); + _elem1063 = _list1065; + } + if (_listLen1066) deallocate ~= _listSrcPtr1066; + auto _witList1067 = WitList!(WitString)(_list1066); + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequest _record1068 = { + requestId: cast(int)(*(cast(uint*)(_base948 + 0))), + actions: _witList1062, + filterStrings: _witList1067, + filterCause: cast(int)(*(cast(uint*)(_base948 + (5*size_t.sizeof)))), + }; + _elem948 = _record1068; + } + if (_listLen1069) deallocate ~= _listSrcPtr1069; + auto _witList1070 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequest)(_list1069); + wit.pumpkin.plugin.bedrock_packets.common.SItemStackRequest _record1071 = { + requests: _witList1070, + }; + auto _payload1377 = _record1071; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sItemStackRequest(_payload1377); + break; + } + case _Tag1365.sLoadingScreen: { + Option!(int) _option1075 = void; + bool _isSome1075 = (cast(uint)(*(cast(ubyte*)(arg0 + 44)))) != 0; + if (_isSome1075) { + + _option1075 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + 48)))); + } else { + _option1075 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.SLoadingScreen _record1076 = { + loadingScreenPacketType: cast(wit.pumpkin.plugin.bedrock_packets.common.LoadingScreenPacketType)(cast(uint)(*(cast(ubyte*)(arg0 + 40)))), + loadingScreenId: _option1075, + }; + auto _payload1378 = _record1076; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sLoadingScreen(_payload1378); + break; + } + case _Tag1365.sLogin: { + auto _len1078 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _ptr1078 = _len1078 ? cast(ubyte*)(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))) : null; + if (_len1078) deallocate ~= cast()_ptr1078; + auto _list1079 = WitList!(ubyte)(_ptr1078[0.._len1078]); + auto _len1080 = *(cast(size_t*)(arg0 + (40+4*size_t.sizeof))); + auto _ptr1080 = _len1080 ? cast(ubyte*)(*(cast(void**)(arg0 + (40+3*size_t.sizeof)))) : null; + if (_len1080) deallocate ~= cast()_ptr1080; + auto _list1081 = WitList!(ubyte)(_ptr1080[0.._len1080]); + wit.pumpkin.plugin.bedrock_packets.common.SLogin _record1082 = { + protocolVersion: cast(int)(*(cast(uint*)(arg0 + 40))), + jwt: _list1079, + rawToken: _list1081, + }; + auto _payload1379 = _record1082; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sLogin(_payload1379); + break; + } + case _Tag1365.sMobEquipment: { + auto _len1084 = *(cast(size_t*)(arg0 + (64+1*size_t.sizeof))); + auto _ptr1084 = _len1084 ? cast(ubyte*)(*(cast(void**)(arg0 + 64))) : null; + if (_len1084) deallocate ~= cast()_ptr1084; + auto _list1085 = WitList!(ubyte)(_ptr1084[0.._len1084]); + Option!(int) _option1088 = void; + bool _isSome1088 = (cast(uint)(*(cast(ubyte*)(arg0 + (64+2*size_t.sizeof))))) != 0; + if (_isSome1088) { + + _option1088 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + (68+2*size_t.sizeof))))); + } else { + _option1088 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.NetworkItemStackDescriptor _record1089 = { + id: cast(int)(*(cast(uint*)(arg0 + 48))), + stackSize: cast(int)(*(cast(uint*)(arg0 + 52))), + auxValue: cast(int)(*(cast(uint*)(arg0 + 56))), + blockRuntimeId: cast(int)(*(cast(uint*)(arg0 + 60))), + extraData: _list1085, + netId: _option1088, + }; + wit.pumpkin.plugin.bedrock_packets.common.SMobEquipment _record1090 = { + entityRuntimeId: cast(long)(*(cast(ulong*)(arg0 + 40))), + item: _record1089, + slot: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (72+2*size_t.sizeof))))), + selectedSlot: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (73+2*size_t.sizeof))))), + containerId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (74+2*size_t.sizeof))))), + }; + auto _payload1380 = _record1090; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sMobEquipment(_payload1380); + break; + } + case _Tag1365.sModalFormResponse: { + Option!(WitString) _option1096 = void; + bool _isSome1096 = (cast(uint)(*(cast(ubyte*)(arg0 + (40+1*size_t.sizeof))))) != 0; + if (_isSome1096) { + auto _len1094 = *(cast(size_t*)(arg0 + (40+3*size_t.sizeof))); + auto _ptr1094 = _len1094 ? cast(char*)(*(cast(void**)(arg0 + (40+2*size_t.sizeof)))) : null; + if (_len1094) deallocate ~= cast()_ptr1094; + auto _list1095 = WitString(_ptr1094[0.._len1094]); + + _option1096 = Option!(WitString).makeSome(_list1095); + } else { + _option1096 = Option!(WitString).makeNone; + } + Option!(ubyte) _option1099 = void; + bool _isSome1099 = (cast(uint)(*(cast(ubyte*)(arg0 + (40+4*size_t.sizeof))))) != 0; + if (_isSome1099) { + + _option1099 = Option!(ubyte).makeSome(cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (41+4*size_t.sizeof)))))); + } else { + _option1099 = Option!(ubyte).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.SModalFormResponse _record1100 = { + formId: cast(int)(*(cast(uint*)(arg0 + 40))), + jsonResponse: _option1096, + formCancelReason: _option1099, + }; + auto _payload1381 = _record1100; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sModalFormResponse(_payload1381); + break; + } + case _Tag1365.sPacketViolationWarning: { + auto _len1102 = *(cast(size_t*)(arg0 + (48+2*size_t.sizeof))); + auto _ptr1102 = _len1102 ? cast(char*)(*(cast(void**)(arg0 + (48+1*size_t.sizeof)))) : null; + if (_len1102) deallocate ~= cast()_ptr1102; + auto _list1103 = WitString(_ptr1102[0.._len1102]); + wit.pumpkin.plugin.bedrock_packets.common.SPacketViolationWarning _record1104 = { + violationType: cast(int)(*(cast(uint*)(arg0 + 40))), + violationSeverity: cast(int)(*(cast(uint*)(arg0 + 44))), + violationPacketId: cast(int)(*(cast(uint*)(arg0 + 48))), + violationContext: _list1103, + }; + auto _payload1382 = _record1104; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sPacketViolationWarning(_payload1382); + break; + } + case _Tag1365.sPlayerAction: { + auto _tuple1106 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 52))), + cast(int)(*(cast(uint*)(arg0 + 56))), + cast(int)(*(cast(uint*)(arg0 + 60))), + ); + auto _tuple1107 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 64))), + cast(int)(*(cast(uint*)(arg0 + 68))), + cast(int)(*(cast(uint*)(arg0 + 72))), + ); + wit.pumpkin.plugin.bedrock_packets.common.SPlayerAction _record1108 = { + playerRuntimeId: cast(long)(*(cast(ulong*)(arg0 + 40))), + action: cast(wit.pumpkin.plugin.bedrock_packets.common.PlayerActionType)(cast(uint)(*(cast(ubyte*)(arg0 + 48)))), + blockPosition: _tuple1106, + resultPos: _tuple1107, + face: cast(int)(*(cast(uint*)(arg0 + 76))), + }; + auto _payload1383 = _record1108; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sPlayerAction(_payload1383); + break; + } + case _Tag1365.sPlayerAuthInput: { + auto _tuple1110 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 48)), + *(cast(double*)(arg0 + 56)), + *(cast(double*)(arg0 + 64)), + ); + auto _tuple1111 = Tuple!(double, double)( + *(cast(double*)(arg0 + 72)), + *(cast(double*)(arg0 + 80)), + ); + auto _len1112 = *(cast(size_t*)(arg0 + (88+2*size_t.sizeof))); + auto _ptr1112 = _len1112 ? cast(long*)(*(cast(void**)(arg0 + (88+1*size_t.sizeof)))) : null; + if (_len1112) deallocate ~= cast()_ptr1112; + auto _list1113 = WitList!(long)(_ptr1112[0.._len1112]); + auto _tuple1114 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + (112+4*size_t.sizeof))), + *(cast(double*)(arg0 + (120+4*size_t.sizeof))), + *(cast(double*)(arg0 + (128+4*size_t.sizeof))), + ); + Option!(WitList!(wit.pumpkin.plugin.bedrock_packets.common.PlayerBlockAction)) _option1119 = void; + bool _isSome1119 = (cast(uint)(*(cast(ubyte*)(arg0 + (136+4*size_t.sizeof))))) != 0; + if (_isSome1119) { + auto _len1117 = *(cast(size_t*)(arg0 + (136+6*size_t.sizeof))); + auto _ptr1117 = _len1117 ? cast(wit.pumpkin.plugin.bedrock_packets.common.PlayerBlockAction*)(*(cast(void**)(arg0 + (136+5*size_t.sizeof)))) : null; + if (_len1117) deallocate ~= cast()_ptr1117; + auto _list1118 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.PlayerBlockAction)(_ptr1117[0.._len1117]); + + _option1119 = Option!(WitList!(wit.pumpkin.plugin.bedrock_packets.common.PlayerBlockAction)).makeSome(_list1118); + } else { + _option1119 = Option!(WitList!(wit.pumpkin.plugin.bedrock_packets.common.PlayerBlockAction)).makeNone; + } + Option!(wit.pumpkin.plugin.bedrock_packets.common.PlayerInventoryAction) _option1182 = void; + bool _isSome1182 = (cast(uint)(*(cast(ubyte*)(arg0 + (144+6*size_t.sizeof))))) != 0; + if (_isSome1182) { + auto _listSrcPtr1126 = *(cast(void**)(arg0 + (152+7*size_t.sizeof))); + auto _listLen1126 = *(cast(size_t*)(arg0 + (152+8*size_t.sizeof))); + auto _list1126 = _listLen1126 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.LegacySetItemSlot)(_listLen1126) : []; + assert(!_listLen1126 || _list1126.ptr); + if (_listLen1126) deallocate ~= cast(void*)_list1126.ptr; + foreach (_elem1122_idx, ref _elem1122; _list1126) { + const auto _base1122 = _listSrcPtr1126 + _elem1122_idx * (3*size_t.sizeof); + auto _len1123 = *(cast(size_t*)(_base1122 + (2*size_t.sizeof))); + auto _ptr1123 = _len1123 ? cast(ubyte*)(*(cast(void**)(_base1122 + size_t.sizeof))) : null; + if (_len1123) deallocate ~= cast()_ptr1123; + auto _list1124 = WitList!(ubyte)(_ptr1123[0.._len1123]); + wit.pumpkin.plugin.bedrock_packets.common.LegacySetItemSlot _record1125 = { + containerId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1122 + 0)))), + slots: _list1124, + }; + _elem1122 = _record1125; + } + if (_listLen1126) deallocate ~= _listSrcPtr1126; + auto _witList1127 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.LegacySetItemSlot)(_list1126); + auto _listSrcPtr1162 = *(cast(void**)(arg0 + (152+9*size_t.sizeof))); + auto _listLen1162 = *(cast(size_t*)(arg0 + (152+10*size_t.sizeof))); + auto _list1162 = _listLen1162 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.InventoryAction)(_listLen1162) : []; + assert(!_listLen1162 || _list1162.ptr); + if (_listLen1162) deallocate ~= cast(void*)_list1162.ptr; + foreach (_elem1128_idx, ref _elem1128; _list1162) { + const auto _base1128 = _listSrcPtr1162 + _elem1128_idx * (72+12*size_t.sizeof); + Option!(int) _option1131 = void; + bool _isSome1131 = (cast(uint)(*(cast(ubyte*)(_base1128 + 4)))) != 0; + if (_isSome1131) { + + _option1131 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base1128 + 8)))); + } else { + _option1131 = Option!(int).makeNone; + } + Option!(int) _option1134 = void; + bool _isSome1134 = (cast(uint)(*(cast(ubyte*)(_base1128 + 12)))) != 0; + if (_isSome1134) { + + _option1134 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base1128 + 16)))); + } else { + _option1134 = Option!(int).makeNone; + } + auto _len1135 = *(cast(size_t*)(_base1128 + (40+1*size_t.sizeof))); + auto _ptr1135 = _len1135 ? cast(char*)(*(cast(void**)(_base1128 + 40))) : null; + if (_len1135) deallocate ~= cast()_ptr1135; + auto _list1136 = WitString(_ptr1135[0.._len1135]); + auto _listSrcPtr1140 = *(cast(void**)(_base1128 + (40+2*size_t.sizeof))); + auto _listLen1140 = *(cast(size_t*)(_base1128 + (40+3*size_t.sizeof))); + auto _list1140 = _listLen1140 ? wit.common.mallocSlice!(WitString)(_listLen1140) : []; + assert(!_listLen1140 || _list1140.ptr); + if (_listLen1140) deallocate ~= cast(void*)_list1140.ptr; + foreach (_elem1137_idx, ref _elem1137; _list1140) { + const auto _base1137 = _listSrcPtr1140 + _elem1137_idx * (2*size_t.sizeof); + auto _len1138 = *(cast(size_t*)(_base1137 + size_t.sizeof)); + auto _ptr1138 = _len1138 ? cast(char*)(*(cast(void**)(_base1137 + 0))) : null; + if (_len1138) deallocate ~= cast()_ptr1138; + auto _list1139 = WitString(_ptr1138[0.._len1138]); + _elem1137 = _list1139; + } + if (_listLen1140) deallocate ~= _listSrcPtr1140; + auto _witList1141 = WitList!(WitString)(_list1140); + auto _listSrcPtr1145 = *(cast(void**)(_base1128 + (40+4*size_t.sizeof))); + auto _listLen1145 = *(cast(size_t*)(_base1128 + (40+5*size_t.sizeof))); + auto _list1145 = _listLen1145 ? wit.common.mallocSlice!(WitString)(_listLen1145) : []; + assert(!_listLen1145 || _list1145.ptr); + if (_listLen1145) deallocate ~= cast(void*)_list1145.ptr; + foreach (_elem1142_idx, ref _elem1142; _list1145) { + const auto _base1142 = _listSrcPtr1145 + _elem1142_idx * (2*size_t.sizeof); + auto _len1143 = *(cast(size_t*)(_base1142 + size_t.sizeof)); + auto _ptr1143 = _len1143 ? cast(char*)(*(cast(void**)(_base1142 + 0))) : null; + if (_len1143) deallocate ~= cast()_ptr1143; + auto _list1144 = WitString(_ptr1143[0.._len1143]); + _elem1142 = _list1144; + } + if (_listLen1145) deallocate ~= _listSrcPtr1145; + auto _witList1146 = WitList!(WitString)(_list1145); + wit.pumpkin.plugin.bedrock_packets.common.NetworkItemDescriptor _record1147 = { + id: cast(int)(*(cast(uint*)(_base1128 + 24))), + stackSize: cast(int)(*(cast(uint*)(_base1128 + 28))), + auxValue: cast(int)(*(cast(uint*)(_base1128 + 32))), + blockRuntimeId: cast(int)(*(cast(uint*)(_base1128 + 36))), + nbtData: _list1136, + placeOnBlocks: _witList1141, + destroyBlocks: _witList1146, + shieldBlockingTick: cast(long)(*(cast(ulong*)(_base1128 + (40+6*size_t.sizeof)))), + }; + auto _len1148 = *(cast(size_t*)(_base1128 + (64+7*size_t.sizeof))); + auto _ptr1148 = _len1148 ? cast(char*)(*(cast(void**)(_base1128 + (64+6*size_t.sizeof)))) : null; + if (_len1148) deallocate ~= cast()_ptr1148; + auto _list1149 = WitString(_ptr1148[0.._len1148]); + auto _listSrcPtr1153 = *(cast(void**)(_base1128 + (64+8*size_t.sizeof))); + auto _listLen1153 = *(cast(size_t*)(_base1128 + (64+9*size_t.sizeof))); + auto _list1153 = _listLen1153 ? wit.common.mallocSlice!(WitString)(_listLen1153) : []; + assert(!_listLen1153 || _list1153.ptr); + if (_listLen1153) deallocate ~= cast(void*)_list1153.ptr; + foreach (_elem1150_idx, ref _elem1150; _list1153) { + const auto _base1150 = _listSrcPtr1153 + _elem1150_idx * (2*size_t.sizeof); + auto _len1151 = *(cast(size_t*)(_base1150 + size_t.sizeof)); + auto _ptr1151 = _len1151 ? cast(char*)(*(cast(void**)(_base1150 + 0))) : null; + if (_len1151) deallocate ~= cast()_ptr1151; + auto _list1152 = WitString(_ptr1151[0.._len1151]); + _elem1150 = _list1152; + } + if (_listLen1153) deallocate ~= _listSrcPtr1153; + auto _witList1154 = WitList!(WitString)(_list1153); + auto _listSrcPtr1158 = *(cast(void**)(_base1128 + (64+10*size_t.sizeof))); + auto _listLen1158 = *(cast(size_t*)(_base1128 + (64+11*size_t.sizeof))); + auto _list1158 = _listLen1158 ? wit.common.mallocSlice!(WitString)(_listLen1158) : []; + assert(!_listLen1158 || _list1158.ptr); + if (_listLen1158) deallocate ~= cast(void*)_list1158.ptr; + foreach (_elem1155_idx, ref _elem1155; _list1158) { + const auto _base1155 = _listSrcPtr1158 + _elem1155_idx * (2*size_t.sizeof); + auto _len1156 = *(cast(size_t*)(_base1155 + size_t.sizeof)); + auto _ptr1156 = _len1156 ? cast(char*)(*(cast(void**)(_base1155 + 0))) : null; + if (_len1156) deallocate ~= cast()_ptr1156; + auto _list1157 = WitString(_ptr1156[0.._len1156]); + _elem1155 = _list1157; + } + if (_listLen1158) deallocate ~= _listSrcPtr1158; + auto _witList1159 = WitList!(WitString)(_list1158); + wit.pumpkin.plugin.bedrock_packets.common.NetworkItemDescriptor _record1160 = { + id: cast(int)(*(cast(uint*)(_base1128 + (48+6*size_t.sizeof)))), + stackSize: cast(int)(*(cast(uint*)(_base1128 + (52+6*size_t.sizeof)))), + auxValue: cast(int)(*(cast(uint*)(_base1128 + (56+6*size_t.sizeof)))), + blockRuntimeId: cast(int)(*(cast(uint*)(_base1128 + (60+6*size_t.sizeof)))), + nbtData: _list1149, + placeOnBlocks: _witList1154, + destroyBlocks: _witList1159, + shieldBlockingTick: cast(long)(*(cast(ulong*)(_base1128 + (64+12*size_t.sizeof)))), + }; + wit.pumpkin.plugin.bedrock_packets.common.InventoryAction _record1161 = { + sourceType: cast(int)(*(cast(uint*)(_base1128 + 0))), + windowId: _option1131, + sourceFlags: _option1134, + inventorySlot: cast(int)(*(cast(uint*)(_base1128 + 20))), + oldItem: _record1147, + newItem: _record1160, + }; + _elem1128 = _record1161; + } + if (_listLen1162) deallocate ~= _listSrcPtr1162; + auto _witList1163 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.InventoryAction)(_list1162); + auto _tuple1164 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + (168+10*size_t.sizeof)))), + cast(int)(*(cast(uint*)(arg0 + (172+10*size_t.sizeof)))), + cast(int)(*(cast(uint*)(arg0 + (176+10*size_t.sizeof)))), + ); + auto _len1165 = *(cast(size_t*)(arg0 + (208+11*size_t.sizeof))); + auto _ptr1165 = _len1165 ? cast(char*)(*(cast(void**)(arg0 + (208+10*size_t.sizeof)))) : null; + if (_len1165) deallocate ~= cast()_ptr1165; + auto _list1166 = WitString(_ptr1165[0.._len1165]); + auto _listSrcPtr1170 = *(cast(void**)(arg0 + (208+12*size_t.sizeof))); + auto _listLen1170 = *(cast(size_t*)(arg0 + (208+13*size_t.sizeof))); + auto _list1170 = _listLen1170 ? wit.common.mallocSlice!(WitString)(_listLen1170) : []; + assert(!_listLen1170 || _list1170.ptr); + if (_listLen1170) deallocate ~= cast(void*)_list1170.ptr; + foreach (_elem1167_idx, ref _elem1167; _list1170) { + const auto _base1167 = _listSrcPtr1170 + _elem1167_idx * (2*size_t.sizeof); + auto _len1168 = *(cast(size_t*)(_base1167 + size_t.sizeof)); + auto _ptr1168 = _len1168 ? cast(char*)(*(cast(void**)(_base1167 + 0))) : null; + if (_len1168) deallocate ~= cast()_ptr1168; + auto _list1169 = WitString(_ptr1168[0.._len1168]); + _elem1167 = _list1169; + } + if (_listLen1170) deallocate ~= _listSrcPtr1170; + auto _witList1171 = WitList!(WitString)(_list1170); + auto _listSrcPtr1175 = *(cast(void**)(arg0 + (208+14*size_t.sizeof))); + auto _listLen1175 = *(cast(size_t*)(arg0 + (208+15*size_t.sizeof))); + auto _list1175 = _listLen1175 ? wit.common.mallocSlice!(WitString)(_listLen1175) : []; + assert(!_listLen1175 || _list1175.ptr); + if (_listLen1175) deallocate ~= cast(void*)_list1175.ptr; + foreach (_elem1172_idx, ref _elem1172; _list1175) { + const auto _base1172 = _listSrcPtr1175 + _elem1172_idx * (2*size_t.sizeof); + auto _len1173 = *(cast(size_t*)(_base1172 + size_t.sizeof)); + auto _ptr1173 = _len1173 ? cast(char*)(*(cast(void**)(_base1172 + 0))) : null; + if (_len1173) deallocate ~= cast()_ptr1173; + auto _list1174 = WitString(_ptr1173[0.._len1173]); + _elem1172 = _list1174; + } + if (_listLen1175) deallocate ~= _listSrcPtr1175; + auto _witList1176 = WitList!(WitString)(_list1175); + wit.pumpkin.plugin.bedrock_packets.common.NetworkItemDescriptor _record1177 = { + id: cast(int)(*(cast(uint*)(arg0 + (192+10*size_t.sizeof)))), + stackSize: cast(int)(*(cast(uint*)(arg0 + (196+10*size_t.sizeof)))), + auxValue: cast(int)(*(cast(uint*)(arg0 + (200+10*size_t.sizeof)))), + blockRuntimeId: cast(int)(*(cast(uint*)(arg0 + (204+10*size_t.sizeof)))), + nbtData: _list1166, + placeOnBlocks: _witList1171, + destroyBlocks: _witList1176, + shieldBlockingTick: cast(long)(*(cast(ulong*)(arg0 + (208+16*size_t.sizeof)))), + }; + auto _tuple1178 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + (216+16*size_t.sizeof))), + *(cast(double*)(arg0 + (224+16*size_t.sizeof))), + *(cast(double*)(arg0 + (232+16*size_t.sizeof))), + ); + auto _tuple1179 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + (240+16*size_t.sizeof))), + *(cast(double*)(arg0 + (248+16*size_t.sizeof))), + *(cast(double*)(arg0 + (256+16*size_t.sizeof))), + ); + wit.pumpkin.plugin.bedrock_packets.common.PlayerUseItemTransactionData _record1180 = { + actionType: cast(int)(*(cast(uint*)(arg0 + (160+10*size_t.sizeof)))), + triggerType: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (164+10*size_t.sizeof))))), + blockPosition: _tuple1164, + blockFace: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (180+10*size_t.sizeof))))), + hotBarSlot: cast(int)(*(cast(uint*)(arg0 + (184+10*size_t.sizeof)))), + itemInHand: _record1177, + playerPosition: _tuple1178, + clickPosition: _tuple1179, + blockRuntimeId: cast(int)(*(cast(uint*)(arg0 + (264+16*size_t.sizeof)))), + clientPrediction: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (268+16*size_t.sizeof))))), + clientCooldownState: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (269+16*size_t.sizeof))))), + }; + wit.pumpkin.plugin.bedrock_packets.common.PlayerInventoryAction _record1181 = { + legacyRequestId: cast(int)(*(cast(uint*)(arg0 + (152+6*size_t.sizeof)))), + legacySlots: _witList1127, + actions: _witList1163, + transaction: _record1180, + }; + + _option1182 = Option!(wit.pumpkin.plugin.bedrock_packets.common.PlayerInventoryAction).makeSome(_record1181); + } else { + _option1182 = Option!(wit.pumpkin.plugin.bedrock_packets.common.PlayerInventoryAction).makeNone; + } + Option!(wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequest) _option1305 = void; + bool _isSome1305 = (cast(uint)(*(cast(ubyte*)(arg0 + (272+16*size_t.sizeof))))) != 0; + if (_isSome1305) { + auto _listSrcPtr1297 = *(cast(void**)(arg0 + (272+18*size_t.sizeof))); + auto _listLen1297 = *(cast(size_t*)(arg0 + (272+19*size_t.sizeof))); + auto _list1297 = _listLen1297 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction)(_listLen1297) : []; + assert(!_listLen1297 || _list1297.ptr); + if (_listLen1297) deallocate ~= cast(void*)_list1297.ptr; + foreach (_elem1185_idx, ref _elem1185; _list1297) { + const auto _base1185 = _listSrcPtr1297 + _elem1185_idx * (40+2*size_t.sizeof); + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction _variant1278 = void; + auto _tag1278 = cast(uint)(*(cast(ubyte*)(_base1185 + 0))); + alias _Tag1278 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.Tag; + final switch (cast(wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.Tag)_tag1278) { + case _Tag1278.take: { + Option!(int) _option1189 = void; + bool _isSome1189 = (cast(uint)(*(cast(ubyte*)(_base1185 + (8+1*size_t.sizeof))))) != 0; + if (_isSome1189) { + + _option1189 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base1185 + (12+1*size_t.sizeof))))); + } else { + _option1189 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.FullContainerName _record1190 = { + containerName: cast(wit.pumpkin.plugin.bedrock_packets.common.ContainerName)(cast(uint)(*(cast(ubyte*)(_base1185 + (4+1*size_t.sizeof))))), + dynamicId: _option1189, + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestSlotInfo _record1191 = { + containerName: _record1190, + slotId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1185 + (16+1*size_t.sizeof))))), + stackId: cast(int)(*(cast(uint*)(_base1185 + (20+1*size_t.sizeof)))), + }; + Option!(int) _option1194 = void; + bool _isSome1194 = (cast(uint)(*(cast(ubyte*)(_base1185 + (28+1*size_t.sizeof))))) != 0; + if (_isSome1194) { + + _option1194 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base1185 + (32+1*size_t.sizeof))))); + } else { + _option1194 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.FullContainerName _record1195 = { + containerName: cast(wit.pumpkin.plugin.bedrock_packets.common.ContainerName)(cast(uint)(*(cast(ubyte*)(_base1185 + (24+1*size_t.sizeof))))), + dynamicId: _option1194, + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestSlotInfo _record1196 = { + containerName: _record1195, + slotId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1185 + (36+1*size_t.sizeof))))), + stackId: cast(int)(*(cast(uint*)(_base1185 + (40+1*size_t.sizeof)))), + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionTake _record1197 = { + count: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1185 + size_t.sizeof)))), + source: _record1191, + destination: _record1196, + }; + auto _payload1279 = _record1197; + _variant1278 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.take(_payload1279); + break; + } + case _Tag1278.place: { + Option!(int) _option1201 = void; + bool _isSome1201 = (cast(uint)(*(cast(ubyte*)(_base1185 + (8+1*size_t.sizeof))))) != 0; + if (_isSome1201) { + + _option1201 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base1185 + (12+1*size_t.sizeof))))); + } else { + _option1201 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.FullContainerName _record1202 = { + containerName: cast(wit.pumpkin.plugin.bedrock_packets.common.ContainerName)(cast(uint)(*(cast(ubyte*)(_base1185 + (4+1*size_t.sizeof))))), + dynamicId: _option1201, + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestSlotInfo _record1203 = { + containerName: _record1202, + slotId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1185 + (16+1*size_t.sizeof))))), + stackId: cast(int)(*(cast(uint*)(_base1185 + (20+1*size_t.sizeof)))), + }; + Option!(int) _option1206 = void; + bool _isSome1206 = (cast(uint)(*(cast(ubyte*)(_base1185 + (28+1*size_t.sizeof))))) != 0; + if (_isSome1206) { + + _option1206 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base1185 + (32+1*size_t.sizeof))))); + } else { + _option1206 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.FullContainerName _record1207 = { + containerName: cast(wit.pumpkin.plugin.bedrock_packets.common.ContainerName)(cast(uint)(*(cast(ubyte*)(_base1185 + (24+1*size_t.sizeof))))), + dynamicId: _option1206, + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestSlotInfo _record1208 = { + containerName: _record1207, + slotId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1185 + (36+1*size_t.sizeof))))), + stackId: cast(int)(*(cast(uint*)(_base1185 + (40+1*size_t.sizeof)))), + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionPlace _record1209 = { + count: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1185 + size_t.sizeof)))), + source: _record1203, + destination: _record1208, + }; + auto _payload1280 = _record1209; + _variant1278 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.place(_payload1280); + break; + } + case _Tag1278.swap: { + Option!(int) _option1213 = void; + bool _isSome1213 = (cast(uint)(*(cast(ubyte*)(_base1185 + (4+1*size_t.sizeof))))) != 0; + if (_isSome1213) { + + _option1213 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base1185 + (8+1*size_t.sizeof))))); + } else { + _option1213 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.FullContainerName _record1214 = { + containerName: cast(wit.pumpkin.plugin.bedrock_packets.common.ContainerName)(cast(uint)(*(cast(ubyte*)(_base1185 + size_t.sizeof)))), + dynamicId: _option1213, + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestSlotInfo _record1215 = { + containerName: _record1214, + slotId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1185 + (12+1*size_t.sizeof))))), + stackId: cast(int)(*(cast(uint*)(_base1185 + (16+1*size_t.sizeof)))), + }; + Option!(int) _option1218 = void; + bool _isSome1218 = (cast(uint)(*(cast(ubyte*)(_base1185 + (24+1*size_t.sizeof))))) != 0; + if (_isSome1218) { + + _option1218 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base1185 + (28+1*size_t.sizeof))))); + } else { + _option1218 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.FullContainerName _record1219 = { + containerName: cast(wit.pumpkin.plugin.bedrock_packets.common.ContainerName)(cast(uint)(*(cast(ubyte*)(_base1185 + (20+1*size_t.sizeof))))), + dynamicId: _option1218, + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestSlotInfo _record1220 = { + containerName: _record1219, + slotId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1185 + (32+1*size_t.sizeof))))), + stackId: cast(int)(*(cast(uint*)(_base1185 + (36+1*size_t.sizeof)))), + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionSwap _record1221 = { + slot1: _record1215, + slot2: _record1220, + }; + auto _payload1281 = _record1221; + _variant1278 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.swap(_payload1281); + break; + } + case _Tag1278.drop: { + Option!(int) _option1225 = void; + bool _isSome1225 = (cast(uint)(*(cast(ubyte*)(_base1185 + (8+1*size_t.sizeof))))) != 0; + if (_isSome1225) { + + _option1225 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base1185 + (12+1*size_t.sizeof))))); + } else { + _option1225 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.FullContainerName _record1226 = { + containerName: cast(wit.pumpkin.plugin.bedrock_packets.common.ContainerName)(cast(uint)(*(cast(ubyte*)(_base1185 + (4+1*size_t.sizeof))))), + dynamicId: _option1225, + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestSlotInfo _record1227 = { + containerName: _record1226, + slotId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1185 + (16+1*size_t.sizeof))))), + stackId: cast(int)(*(cast(uint*)(_base1185 + (20+1*size_t.sizeof)))), + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionDrop _record1228 = { + count: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1185 + size_t.sizeof)))), + source: _record1227, + randomly: (cast(uint)(*(cast(ubyte*)(_base1185 + (24+1*size_t.sizeof))))) != 0, + }; + auto _payload1282 = _record1228; + _variant1278 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.drop(_payload1282); + break; + } + case _Tag1278.destroy: { + Option!(int) _option1232 = void; + bool _isSome1232 = (cast(uint)(*(cast(ubyte*)(_base1185 + (8+1*size_t.sizeof))))) != 0; + if (_isSome1232) { + + _option1232 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base1185 + (12+1*size_t.sizeof))))); + } else { + _option1232 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.FullContainerName _record1233 = { + containerName: cast(wit.pumpkin.plugin.bedrock_packets.common.ContainerName)(cast(uint)(*(cast(ubyte*)(_base1185 + (4+1*size_t.sizeof))))), + dynamicId: _option1232, + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestSlotInfo _record1234 = { + containerName: _record1233, + slotId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1185 + (16+1*size_t.sizeof))))), + stackId: cast(int)(*(cast(uint*)(_base1185 + (20+1*size_t.sizeof)))), + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionDestroy _record1235 = { + count: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1185 + size_t.sizeof)))), + source: _record1234, + }; + auto _payload1283 = _record1235; + _variant1278 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.destroy(_payload1283); + break; + } + case _Tag1278.consume: { + Option!(int) _option1239 = void; + bool _isSome1239 = (cast(uint)(*(cast(ubyte*)(_base1185 + (8+1*size_t.sizeof))))) != 0; + if (_isSome1239) { + + _option1239 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base1185 + (12+1*size_t.sizeof))))); + } else { + _option1239 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.FullContainerName _record1240 = { + containerName: cast(wit.pumpkin.plugin.bedrock_packets.common.ContainerName)(cast(uint)(*(cast(ubyte*)(_base1185 + (4+1*size_t.sizeof))))), + dynamicId: _option1239, + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestSlotInfo _record1241 = { + containerName: _record1240, + slotId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1185 + (16+1*size_t.sizeof))))), + stackId: cast(int)(*(cast(uint*)(_base1185 + (20+1*size_t.sizeof)))), + }; + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionConsume _record1242 = { + count: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1185 + size_t.sizeof)))), + source: _record1241, + }; + auto _payload1284 = _record1242; + _variant1278 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.consume(_payload1284); + break; + } + case _Tag1278.create: { + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionCreate _record1244 = { + resultIndex: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1185 + size_t.sizeof)))), + }; + auto _payload1285 = _record1244; + _variant1278 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.create(_payload1285); + break; + } + case _Tag1278.labTableCombine: { + _variant1278 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.labTableCombine(); + break; + } + case _Tag1278.beaconPayment: { + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionBeaconPayment _record1247 = { + primaryEffectId: cast(int)(*(cast(uint*)(_base1185 + size_t.sizeof))), + secondaryEffectId: cast(int)(*(cast(uint*)(_base1185 + (4+1*size_t.sizeof)))), + }; + auto _payload1287 = _record1247; + _variant1278 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.beaconPayment(_payload1287); + break; + } + case _Tag1278.mineBlock: { + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionMineBlock _record1249 = { + hotbarSlot: cast(int)(*(cast(uint*)(_base1185 + size_t.sizeof))), + predictedDurability: cast(int)(*(cast(uint*)(_base1185 + (4+1*size_t.sizeof)))), + stackId: cast(int)(*(cast(uint*)(_base1185 + (8+1*size_t.sizeof)))), + }; + auto _payload1288 = _record1249; + _variant1278 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.mineBlock(_payload1288); + break; + } + case _Tag1278.craftRecipe: { + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionCraftRecipe _record1251 = { + recipeId: cast(int)(*(cast(uint*)(_base1185 + size_t.sizeof))), + repetitions: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1185 + (4+1*size_t.sizeof))))), + }; + auto _payload1289 = _record1251; + _variant1278 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.craftRecipe(_payload1289); + break; + } + case _Tag1278.craftRecipeAuto: { + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionCraftRecipeAuto _record1253 = { + recipeId: cast(int)(*(cast(uint*)(_base1185 + size_t.sizeof))), + repetitions: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1185 + (4+1*size_t.sizeof))))), + }; + auto _payload1290 = _record1253; + _variant1278 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.craftRecipeAuto(_payload1290); + break; + } + case _Tag1278.craftCreative: { + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionCraftCreative _record1255 = { + creativeItemId: cast(int)(*(cast(uint*)(_base1185 + size_t.sizeof))), + repetitions: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1185 + (4+1*size_t.sizeof))))), + }; + auto _payload1291 = _record1255; + _variant1278 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.craftCreative(_payload1291); + break; + } + case _Tag1278.optional: { + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionOptional _record1257 = { + recipeId: cast(int)(*(cast(uint*)(_base1185 + size_t.sizeof))), + filterStringIndex: cast(int)(*(cast(uint*)(_base1185 + (4+1*size_t.sizeof)))), + }; + auto _payload1292 = _record1257; + _variant1278 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.optional(_payload1292); + break; + } + case _Tag1278.grindstone: { + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionGrindstone _record1259 = { + recipeId: cast(int)(*(cast(uint*)(_base1185 + size_t.sizeof))), + repairCost: cast(int)(*(cast(uint*)(_base1185 + (4+1*size_t.sizeof)))), + repetitions: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1185 + (8+1*size_t.sizeof))))), + }; + auto _payload1293 = _record1259; + _variant1278 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.grindstone(_payload1293); + break; + } + case _Tag1278.loom: { + auto _len1261 = *(cast(size_t*)(_base1185 + (2*size_t.sizeof))); + auto _ptr1261 = _len1261 ? cast(char*)(*(cast(void**)(_base1185 + size_t.sizeof))) : null; + if (_len1261) deallocate ~= cast()_ptr1261; + auto _list1262 = WitString(_ptr1261[0.._len1261]); + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionLoom _record1263 = { + patternId: _list1262, + repetitions: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1185 + (3*size_t.sizeof))))), + }; + auto _payload1294 = _record1263; + _variant1278 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.loom(_payload1294); + break; + } + case _Tag1278.craftNonImplemented: { + _variant1278 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.craftNonImplemented(); + break; + } + case _Tag1278.craftResultsDeprecated: { + auto _listSrcPtr1275 = *(cast(void**)(_base1185 + size_t.sizeof)); + auto _listLen1275 = *(cast(size_t*)(_base1185 + (2*size_t.sizeof))); + auto _list1275 = _listLen1275 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.StackRequestItem)(_listLen1275) : []; + assert(!_listLen1275 || _list1275.ptr); + if (_listLen1275) deallocate ~= cast(void*)_list1275.ptr; + foreach (_elem1266_idx, ref _elem1266; _list1275) { + const auto _base1266 = _listSrcPtr1275 + _elem1266_idx * (8+6*size_t.sizeof); + Option!(WitString) _option1271 = void; + bool _isSome1271 = (cast(uint)(*(cast(ubyte*)(_base1266 + 0)))) != 0; + if (_isSome1271) { + auto _len1269 = *(cast(size_t*)(_base1266 + (2*size_t.sizeof))); + auto _ptr1269 = _len1269 ? cast(char*)(*(cast(void**)(_base1266 + size_t.sizeof))) : null; + if (_len1269) deallocate ~= cast()_ptr1269; + auto _list1270 = WitString(_ptr1269[0.._len1269]); + + _option1271 = Option!(WitString).makeSome(_list1270); + } else { + _option1271 = Option!(WitString).makeNone; + } + auto _len1272 = *(cast(size_t*)(_base1266 + (8+5*size_t.sizeof))); + auto _ptr1272 = _len1272 ? cast(ubyte*)(*(cast(void**)(_base1266 + (8+4*size_t.sizeof)))) : null; + if (_len1272) deallocate ~= cast()_ptr1272; + auto _list1273 = WitList!(ubyte)(_ptr1272[0.._len1272]); + wit.pumpkin.plugin.bedrock_packets.common.StackRequestItem _record1274 = { + identifier: _option1271, + metadataValue: cast(int)(*(cast(uint*)(_base1266 + (3*size_t.sizeof)))), + count: cast(int)(*(cast(uint*)(_base1266 + (4+3*size_t.sizeof)))), + blockRuntimeId: cast(int)(*(cast(uint*)(_base1266 + (8+3*size_t.sizeof)))), + extraData: _list1273, + }; + _elem1266 = _record1274; + } + if (_listLen1275) deallocate ~= _listSrcPtr1275; + auto _witList1276 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.StackRequestItem)(_list1275); + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionCraftResultsDeprecated _record1277 = { + resultItems: _witList1276, + timesCrafted: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1185 + (3*size_t.sizeof))))), + }; + auto _payload1296 = _record1277; + _variant1278 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.craftResultsDeprecated(_payload1296); + break; + } + } + _elem1185 = _variant1278; + } + if (_listLen1297) deallocate ~= _listSrcPtr1297; + auto _witList1298 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction)(_list1297); + auto _listSrcPtr1302 = *(cast(void**)(arg0 + (272+20*size_t.sizeof))); + auto _listLen1302 = *(cast(size_t*)(arg0 + (272+21*size_t.sizeof))); + auto _list1302 = _listLen1302 ? wit.common.mallocSlice!(WitString)(_listLen1302) : []; + assert(!_listLen1302 || _list1302.ptr); + if (_listLen1302) deallocate ~= cast(void*)_list1302.ptr; + foreach (_elem1299_idx, ref _elem1299; _list1302) { + const auto _base1299 = _listSrcPtr1302 + _elem1299_idx * (2*size_t.sizeof); + auto _len1300 = *(cast(size_t*)(_base1299 + size_t.sizeof)); + auto _ptr1300 = _len1300 ? cast(char*)(*(cast(void**)(_base1299 + 0))) : null; + if (_len1300) deallocate ~= cast()_ptr1300; + auto _list1301 = WitString(_ptr1300[0.._len1300]); + _elem1299 = _list1301; + } + if (_listLen1302) deallocate ~= _listSrcPtr1302; + auto _witList1303 = WitList!(WitString)(_list1302); + wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequest _record1304 = { + requestId: cast(int)(*(cast(uint*)(arg0 + (272+17*size_t.sizeof)))), + actions: _witList1298, + filterStrings: _witList1303, + filterCause: cast(int)(*(cast(uint*)(arg0 + (272+22*size_t.sizeof)))), + }; + + _option1305 = Option!(wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequest).makeSome(_record1304); + } else { + _option1305 = Option!(wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequest).makeNone; + } + Option!(Tuple!(double, double)) _option1309 = void; + bool _isSome1309 = (cast(uint)(*(cast(ubyte*)(arg0 + (280+22*size_t.sizeof))))) != 0; + if (_isSome1309) { + auto _tuple1308 = Tuple!(double, double)( + *(cast(double*)(arg0 + (288+22*size_t.sizeof))), + *(cast(double*)(arg0 + (296+22*size_t.sizeof))), + ); + + _option1309 = Option!(Tuple!(double, double)).makeSome(_tuple1308); + } else { + _option1309 = Option!(Tuple!(double, double)).makeNone; + } + Option!(long) _option1312 = void; + bool _isSome1312 = (cast(uint)(*(cast(ubyte*)(arg0 + (304+22*size_t.sizeof))))) != 0; + if (_isSome1312) { + + _option1312 = Option!(long).makeSome(cast(long)(*(cast(ulong*)(arg0 + (312+22*size_t.sizeof))))); + } else { + _option1312 = Option!(long).makeNone; + } + auto _tuple1313 = Tuple!(double, double)( + *(cast(double*)(arg0 + (320+22*size_t.sizeof))), + *(cast(double*)(arg0 + (328+22*size_t.sizeof))), + ); + auto _tuple1314 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + (336+22*size_t.sizeof))), + *(cast(double*)(arg0 + (344+22*size_t.sizeof))), + *(cast(double*)(arg0 + (352+22*size_t.sizeof))), + ); + auto _tuple1315 = Tuple!(double, double)( + *(cast(double*)(arg0 + (360+22*size_t.sizeof))), + *(cast(double*)(arg0 + (368+22*size_t.sizeof))), + ); + wit.pumpkin.plugin.bedrock_packets.common.SPlayerAuthInput _record1316 = { + pitch: *(cast(float*)(arg0 + 40)), + yaw: *(cast(float*)(arg0 + 44)), + position: _tuple1110, + moveVec: _tuple1111, + headYaw: *(cast(float*)(arg0 + 88)), + inputData: _list1113, + inputMode: cast(int)(*(cast(uint*)(arg0 + (88+3*size_t.sizeof)))), + playMode: cast(int)(*(cast(uint*)(arg0 + (92+3*size_t.sizeof)))), + interactionModel: cast(int)(*(cast(uint*)(arg0 + (96+3*size_t.sizeof)))), + interactPitch: *(cast(float*)(arg0 + (100+3*size_t.sizeof))), + interactYaw: *(cast(float*)(arg0 + (104+3*size_t.sizeof))), + tick: cast(long)(*(cast(ulong*)(arg0 + (104+4*size_t.sizeof)))), + delta: _tuple1114, + blockActions: _option1119, + itemInteraction: _option1182, + itemStackRequest: _option1305, + vehicleRotation: _option1309, + vehicleUniqueId: _option1312, + analogMove: _tuple1313, + cameraOrientation: _tuple1314, + rawMove: _tuple1315, + }; + auto _payload1384 = _record1316; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sPlayerAuthInput(_payload1384); + break; + } + case _Tag1365.sPlayerHotbar: { + wit.pumpkin.plugin.bedrock_packets.common.SPlayerHotbar _record1318 = { + selectedSlot: cast(int)(*(cast(uint*)(arg0 + 40))), + containerId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 44)))), + shouldSelectSlot: (cast(uint)(*(cast(ubyte*)(arg0 + 45)))) != 0, + }; + auto _payload1385 = _record1318; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sPlayerHotbar(_payload1385); + break; + } + case _Tag1365.sRequestAbility: { + wit.pumpkin.plugin.bedrock_packets.common.AbilityValue _variant1322 = void; + auto _tag1322 = cast(uint)(*(cast(ubyte*)(arg0 + 44))); + alias _Tag1322 = wit.pumpkin.plugin.bedrock_packets.common.AbilityValue.Tag; + final switch (cast(wit.pumpkin.plugin.bedrock_packets.common.AbilityValue.Tag)_tag1322) { + case _Tag1322.bool_: { + auto _payload1323 = (cast(uint)(*(cast(ubyte*)(arg0 + 48)))) != 0; + _variant1322 = wit.pumpkin.plugin.bedrock_packets.common.AbilityValue.bool_(_payload1323); + break; + } + case _Tag1322.float_: { + auto _payload1324 = *(cast(float*)(arg0 + 48)); + _variant1322 = wit.pumpkin.plugin.bedrock_packets.common.AbilityValue.float_(_payload1324); + break; + } + } + wit.pumpkin.plugin.bedrock_packets.common.SRequestAbility _record1325 = { + ability: cast(int)(*(cast(uint*)(arg0 + 40))), + value: _variant1322, + }; + auto _payload1386 = _record1325; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sRequestAbility(_payload1386); + break; + } + case _Tag1365.sRequestChunkRadius: { + wit.pumpkin.plugin.bedrock_packets.common.SRequestChunkRadius _record1327 = { + chunkRadius: cast(int)(*(cast(uint*)(arg0 + 40))), + maxChunkRadius: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 44)))), + }; + auto _payload1387 = _record1327; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sRequestChunkRadius(_payload1387); + break; + } + case _Tag1365.sRequestNetworkSettings: { + wit.pumpkin.plugin.bedrock_packets.common.SRequestNetworkSettings _record1329 = { + clientNetworkVersion: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload1388 = _record1329; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sRequestNetworkSettings(_payload1388); + break; + } + case _Tag1365.sResourcePackClientResponse: { + auto _listSrcPtr1334 = *(cast(void**)(arg0 + 48)); + auto _listLen1334 = *(cast(size_t*)(arg0 + (48+1*size_t.sizeof))); + auto _list1334 = _listLen1334 ? wit.common.mallocSlice!(WitString)(_listLen1334) : []; + assert(!_listLen1334 || _list1334.ptr); + if (_listLen1334) deallocate ~= cast(void*)_list1334.ptr; + foreach (_elem1331_idx, ref _elem1331; _list1334) { + const auto _base1331 = _listSrcPtr1334 + _elem1331_idx * (2*size_t.sizeof); + auto _len1332 = *(cast(size_t*)(_base1331 + size_t.sizeof)); + auto _ptr1332 = _len1332 ? cast(char*)(*(cast(void**)(_base1331 + 0))) : null; + if (_len1332) deallocate ~= cast()_ptr1332; + auto _list1333 = WitString(_ptr1332[0.._len1332]); + _elem1331 = _list1333; + } + if (_listLen1334) deallocate ~= _listSrcPtr1334; + auto _witList1335 = WitList!(WitString)(_list1334); + wit.pumpkin.plugin.bedrock_packets.common.SResourcePackClientResponse _record1336 = { + response: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 40)))), + downloadSize: cast(int)(*(cast(uint*)(arg0 + 44))), + packIds: _witList1335, + }; + auto _payload1389 = _record1336; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sResourcePackClientResponse(_payload1389); + break; + } + case _Tag1365.sRespawn: { + auto _tuple1338 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 40)), + *(cast(double*)(arg0 + 48)), + *(cast(double*)(arg0 + 56)), + ); + wit.pumpkin.plugin.bedrock_packets.common.SRespawn _record1339 = { + position: _tuple1338, + state: cast(wit.pumpkin.plugin.bedrock_packets.common.RespawnState)(cast(uint)(*(cast(ubyte*)(arg0 + 64)))), + playerRuntimeId: cast(long)(*(cast(ulong*)(arg0 + 72))), + }; + auto _payload1390 = _record1339; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sRespawn(_payload1390); + break; + } + case _Tag1365.sSetLocalPlayerAsInitialized: { + wit.pumpkin.plugin.bedrock_packets.common.SSetLocalPlayerAsInitialized _record1341 = { + playerId: cast(long)(*(cast(ulong*)(arg0 + 40))), + }; + auto _payload1391 = _record1341; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sSetLocalPlayerAsInitialized(_payload1391); + break; + } + case _Tag1365.sSetPlayerInventoryOptions: { + wit.pumpkin.plugin.bedrock_packets.common.SSetPlayerInventoryOptions _record1343 = { + leftInventoryTab: cast(int)(*(cast(uint*)(arg0 + 40))), + rightInventoryTab: cast(int)(*(cast(uint*)(arg0 + 44))), + filtering: (cast(uint)(*(cast(ubyte*)(arg0 + 48)))) != 0, + layoutInv: cast(int)(*(cast(uint*)(arg0 + 52))), + layoutCraft: cast(int)(*(cast(uint*)(arg0 + 56))), + }; + auto _payload1392 = _record1343; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sSetPlayerInventoryOptions(_payload1392); + break; + } + case _Tag1365.sText: { + auto _len1345 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _ptr1345 = _len1345 ? cast(char*)(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))) : null; + if (_len1345) deallocate ~= cast()_ptr1345; + auto _list1346 = WitString(_ptr1345[0.._len1345]); + auto _len1347 = *(cast(size_t*)(arg0 + (40+4*size_t.sizeof))); + auto _ptr1347 = _len1347 ? cast(char*)(*(cast(void**)(arg0 + (40+3*size_t.sizeof)))) : null; + if (_len1347) deallocate ~= cast()_ptr1347; + auto _list1348 = WitString(_ptr1347[0.._len1347]); + auto _listSrcPtr1352 = *(cast(void**)(arg0 + (40+5*size_t.sizeof))); + auto _listLen1352 = *(cast(size_t*)(arg0 + (40+6*size_t.sizeof))); + auto _list1352 = _listLen1352 ? wit.common.mallocSlice!(WitString)(_listLen1352) : []; + assert(!_listLen1352 || _list1352.ptr); + if (_listLen1352) deallocate ~= cast(void*)_list1352.ptr; + foreach (_elem1349_idx, ref _elem1349; _list1352) { + const auto _base1349 = _listSrcPtr1352 + _elem1349_idx * (2*size_t.sizeof); + auto _len1350 = *(cast(size_t*)(_base1349 + size_t.sizeof)); + auto _ptr1350 = _len1350 ? cast(char*)(*(cast(void**)(_base1349 + 0))) : null; + if (_len1350) deallocate ~= cast()_ptr1350; + auto _list1351 = WitString(_ptr1350[0.._len1350]); + _elem1349 = _list1351; + } + if (_listLen1352) deallocate ~= _listSrcPtr1352; + auto _witList1353 = WitList!(WitString)(_list1352); + auto _len1354 = *(cast(size_t*)(arg0 + (40+8*size_t.sizeof))); + auto _ptr1354 = _len1354 ? cast(char*)(*(cast(void**)(arg0 + (40+7*size_t.sizeof)))) : null; + if (_len1354) deallocate ~= cast()_ptr1354; + auto _list1355 = WitString(_ptr1354[0.._len1354]); + auto _len1356 = *(cast(size_t*)(arg0 + (40+10*size_t.sizeof))); + auto _ptr1356 = _len1356 ? cast(char*)(*(cast(void**)(arg0 + (40+9*size_t.sizeof)))) : null; + if (_len1356) deallocate ~= cast()_ptr1356; + auto _list1357 = WitString(_ptr1356[0.._len1356]); + Option!(WitString) _option1362 = void; + bool _isSome1362 = (cast(uint)(*(cast(ubyte*)(arg0 + (40+11*size_t.sizeof))))) != 0; + if (_isSome1362) { + auto _len1360 = *(cast(size_t*)(arg0 + (40+13*size_t.sizeof))); + auto _ptr1360 = _len1360 ? cast(char*)(*(cast(void**)(arg0 + (40+12*size_t.sizeof)))) : null; + if (_len1360) deallocate ~= cast()_ptr1360; + auto _list1361 = WitString(_ptr1360[0.._len1360]); + + _option1362 = Option!(WitString).makeSome(_list1361); + } else { + _option1362 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.SText _record1363 = { + needsTranslation: (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0, + rType: cast(wit.pumpkin.plugin.bedrock_packets.common.TextPacketType)(cast(uint)(*(cast(ubyte*)(arg0 + 41)))), + sourceName: _list1346, + message: _list1348, + parameters: _witList1353, + xuid: _list1355, + platformChatId: _list1357, + filteredMessage: _option1362, + }; + auto _payload1393 = _record1363; + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.sText(_payload1393); + break; + } + case _Tag1365.unknown: { + _variant1365 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.unknown(); + break; + } + } + auto _payload1398 = _variant1365; + _variant1396 = wit.pumpkin.plugin.event.common.ServerboundPacket.bedrock(_payload1398); + break; + } + case _Tag1396.unknown: { + _variant1396 = wit.pumpkin.plugin.event.common.ServerboundPacket.unknown(); + break; + } + } + auto _len1400 = *(cast(size_t*)(arg0 + (376+24*size_t.sizeof))); + auto _ptr1400 = _len1400 ? cast(ubyte*)(*(cast(void**)(arg0 + (376+23*size_t.sizeof)))) : null; + if (_len1400) deallocate ~= cast()_ptr1400; + auto _list1401 = WitList!(ubyte)(_ptr1400[0.._len1400]); + wit.pumpkin.plugin.event.imports.PacketReceivedEventData _record1402 = { + player: _handle323, + packet: _variant1396, + packetId: cast(int)(*(cast(uint*)(arg0 + (376+22*size_t.sizeof)))), + rawPayload: _list1401, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (376+25*size_t.sizeof))))) != 0, + }; + auto _payload4563 = _record1402; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.packetReceivedEvent(_payload4563); + break; + } + case _Tag4520.packetSentEvent: { + auto _handle1404 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.common.ClientboundPacket _variant3519 = void; + auto _tag3519 = cast(uint)(*(cast(ubyte*)(arg0 + 24))); + alias _Tag3519 = wit.pumpkin.plugin.event.common.ClientboundPacket.Tag; + final switch (cast(wit.pumpkin.plugin.event.common.ClientboundPacket.Tag)_tag3519) { + case _Tag3519.java: { + wit.pumpkin.plugin.java_packets.common.ClientboundPacket _variant2551 = void; + auto _tag2551 = cast(uint)(*(cast(ubyte*)(arg0 + 32))); + alias _Tag2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.Tag; + final switch (cast(wit.pumpkin.plugin.java_packets.common.ClientboundPacket.Tag)_tag2551) { + case _Tag2551.configCConfigAddResourcePack: { + wit.pumpkin.plugin.uuid.common.Uuid _record1407 = { + high: *(cast(ulong*)(arg0 + 40)), + low: *(cast(ulong*)(arg0 + 48)), + }; + auto _len1408 = *(cast(size_t*)(arg0 + (56+1*size_t.sizeof))); + auto _ptr1408 = _len1408 ? cast(char*)(*(cast(void**)(arg0 + 56))) : null; + if (_len1408) deallocate ~= cast()_ptr1408; + auto _list1409 = WitString(_ptr1408[0.._len1408]); + auto _len1410 = *(cast(size_t*)(arg0 + (56+3*size_t.sizeof))); + auto _ptr1410 = _len1410 ? cast(char*)(*(cast(void**)(arg0 + (56+2*size_t.sizeof)))) : null; + if (_len1410) deallocate ~= cast()_ptr1410; + auto _list1411 = WitString(_ptr1410[0.._len1410]); + Option!(WitString) _option1416 = void; + bool _isSome1416 = (cast(uint)(*(cast(ubyte*)(arg0 + (56+5*size_t.sizeof))))) != 0; + if (_isSome1416) { + auto _len1414 = *(cast(size_t*)(arg0 + (56+7*size_t.sizeof))); + auto _ptr1414 = _len1414 ? cast(char*)(*(cast(void**)(arg0 + (56+6*size_t.sizeof)))) : null; + if (_len1414) deallocate ~= cast()_ptr1414; + auto _list1415 = WitString(_ptr1414[0.._len1414]); + + _option1416 = Option!(WitString).makeSome(_list1415); + } else { + _option1416 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.java_packets.common.ConfigCConfigAddResourcePack _record1417 = { + uuid: _record1407, + url: _list1409, + hash: _list1411, + forced: (cast(uint)(*(cast(ubyte*)(arg0 + (56+4*size_t.sizeof))))) != 0, + promptMessage: _option1416, + }; + auto _payload2552 = _record1417; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.configCConfigAddResourcePack(_payload2552); + break; + } + case _Tag2551.configCConfigClearDialog: { + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.configCConfigClearDialog(); + break; + } + case _Tag2551.configCCodeOfConduct: { + auto _len1420 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr1420 = _len1420 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len1420) deallocate ~= cast()_ptr1420; + auto _list1421 = WitString(_ptr1420[0.._len1420]); + wit.pumpkin.plugin.java_packets.common.ConfigCCodeOfConduct _record1422 = { + codeOfConduct: _list1421, + }; + auto _payload2554 = _record1422; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.configCCodeOfConduct(_payload2554); + break; + } + case _Tag2551.configCConfigDisconnect: { + auto _len1424 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr1424 = _len1424 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len1424) deallocate ~= cast()_ptr1424; + auto _list1425 = WitString(_ptr1424[0.._len1424]); + wit.pumpkin.plugin.java_packets.common.ConfigCConfigDisconnect _record1426 = { + reason: _list1425, + }; + auto _payload2555 = _record1426; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.configCConfigDisconnect(_payload2555); + break; + } + case _Tag2551.configCCookieRequest: { + auto _len1428 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr1428 = _len1428 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len1428) deallocate ~= cast()_ptr1428; + auto _list1429 = WitString(_ptr1428[0.._len1428]); + wit.pumpkin.plugin.java_packets.common.ConfigCCookieRequest _record1430 = { + key: _list1429, + }; + auto _payload2556 = _record1430; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.configCCookieRequest(_payload2556); + break; + } + case _Tag2551.configCConfigCustomReportDetails: { + auto _listSrcPtr1438 = *(cast(void**)(arg0 + 40)); + auto _listLen1438 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _list1438 = _listLen1438 ? wit.common.mallocSlice!(Tuple!(WitString, WitString))(_listLen1438) : []; + assert(!_listLen1438 || _list1438.ptr); + if (_listLen1438) deallocate ~= cast(void*)_list1438.ptr; + foreach (_elem1432_idx, ref _elem1432; _list1438) { + const auto _base1432 = _listSrcPtr1438 + _elem1432_idx * (4*size_t.sizeof); + auto _len1433 = *(cast(size_t*)(_base1432 + size_t.sizeof)); + auto _ptr1433 = _len1433 ? cast(char*)(*(cast(void**)(_base1432 + 0))) : null; + if (_len1433) deallocate ~= cast()_ptr1433; + auto _list1434 = WitString(_ptr1433[0.._len1433]); + auto _len1435 = *(cast(size_t*)(_base1432 + (3*size_t.sizeof))); + auto _ptr1435 = _len1435 ? cast(char*)(*(cast(void**)(_base1432 + (2*size_t.sizeof)))) : null; + if (_len1435) deallocate ~= cast()_ptr1435; + auto _list1436 = WitString(_ptr1435[0.._len1435]); + auto _tuple1437 = Tuple!(WitString, WitString)( + _list1434, + _list1436, + ); + _elem1432 = _tuple1437; + } + if (_listLen1438) deallocate ~= _listSrcPtr1438; + auto _witList1439 = WitList!(Tuple!(WitString, WitString))(_list1438); + wit.pumpkin.plugin.java_packets.common.ConfigCConfigCustomReportDetails _record1440 = { + details: _witList1439, + }; + auto _payload2557 = _record1440; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.configCConfigCustomReportDetails(_payload2557); + break; + } + case _Tag2551.configCFeatureFlags: { + auto _listSrcPtr1445 = *(cast(void**)(arg0 + 40)); + auto _listLen1445 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _list1445 = _listLen1445 ? wit.common.mallocSlice!(WitString)(_listLen1445) : []; + assert(!_listLen1445 || _list1445.ptr); + if (_listLen1445) deallocate ~= cast(void*)_list1445.ptr; + foreach (_elem1442_idx, ref _elem1442; _list1445) { + const auto _base1442 = _listSrcPtr1445 + _elem1442_idx * (2*size_t.sizeof); + auto _len1443 = *(cast(size_t*)(_base1442 + size_t.sizeof)); + auto _ptr1443 = _len1443 ? cast(char*)(*(cast(void**)(_base1442 + 0))) : null; + if (_len1443) deallocate ~= cast()_ptr1443; + auto _list1444 = WitString(_ptr1443[0.._len1443]); + _elem1442 = _list1444; + } + if (_listLen1445) deallocate ~= _listSrcPtr1445; + auto _witList1446 = WitList!(WitString)(_list1445); + wit.pumpkin.plugin.java_packets.common.ConfigCFeatureFlags _record1447 = { + features: _witList1446, + }; + auto _payload2558 = _record1447; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.configCFeatureFlags(_payload2558); + break; + } + case _Tag2551.configCFinishConfig: { + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.configCFinishConfig(); + break; + } + case _Tag2551.configCKnownPacks: { + auto _listSrcPtr1453 = *(cast(void**)(arg0 + 40)); + auto _listLen1453 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _list1453 = _listLen1453 ? wit.common.mallocSlice!(WitString)(_listLen1453) : []; + assert(!_listLen1453 || _list1453.ptr); + if (_listLen1453) deallocate ~= cast(void*)_list1453.ptr; + foreach (_elem1450_idx, ref _elem1450; _list1453) { + const auto _base1450 = _listSrcPtr1453 + _elem1450_idx * (2*size_t.sizeof); + auto _len1451 = *(cast(size_t*)(_base1450 + size_t.sizeof)); + auto _ptr1451 = _len1451 ? cast(char*)(*(cast(void**)(_base1450 + 0))) : null; + if (_len1451) deallocate ~= cast()_ptr1451; + auto _list1452 = WitString(_ptr1451[0.._len1451]); + _elem1450 = _list1452; + } + if (_listLen1453) deallocate ~= _listSrcPtr1453; + auto _witList1454 = WitList!(WitString)(_list1453); + wit.pumpkin.plugin.java_packets.common.ConfigCKnownPacks _record1455 = { + knownPacks: _witList1454, + }; + auto _payload2560 = _record1455; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.configCKnownPacks(_payload2560); + break; + } + case _Tag2551.configCConfigPing: { + wit.pumpkin.plugin.java_packets.common.ConfigCConfigPing _record1457 = { + id: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload2561 = _record1457; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.configCConfigPing(_payload2561); + break; + } + case _Tag2551.configCPluginMessage: { + auto _len1459 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr1459 = _len1459 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len1459) deallocate ~= cast()_ptr1459; + auto _list1460 = WitString(_ptr1459[0.._len1459]); + auto _len1461 = *(cast(size_t*)(arg0 + (40+3*size_t.sizeof))); + auto _ptr1461 = _len1461 ? cast(ubyte*)(*(cast(void**)(arg0 + (40+2*size_t.sizeof)))) : null; + if (_len1461) deallocate ~= cast()_ptr1461; + auto _list1462 = WitList!(ubyte)(_ptr1461[0.._len1461]); + wit.pumpkin.plugin.java_packets.common.ConfigCPluginMessage _record1463 = { + channel: _list1460, + data: _list1462, + }; + auto _payload2562 = _record1463; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.configCPluginMessage(_payload2562); + break; + } + case _Tag2551.configCRegistryData: { + auto _len1465 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr1465 = _len1465 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len1465) deallocate ~= cast()_ptr1465; + auto _list1466 = WitString(_ptr1465[0.._len1465]); + auto _listSrcPtr1470 = *(cast(void**)(arg0 + (40+2*size_t.sizeof))); + auto _listLen1470 = *(cast(size_t*)(arg0 + (40+3*size_t.sizeof))); + auto _list1470 = _listLen1470 ? wit.common.mallocSlice!(WitString)(_listLen1470) : []; + assert(!_listLen1470 || _list1470.ptr); + if (_listLen1470) deallocate ~= cast(void*)_list1470.ptr; + foreach (_elem1467_idx, ref _elem1467; _list1470) { + const auto _base1467 = _listSrcPtr1470 + _elem1467_idx * (2*size_t.sizeof); + auto _len1468 = *(cast(size_t*)(_base1467 + size_t.sizeof)); + auto _ptr1468 = _len1468 ? cast(char*)(*(cast(void**)(_base1467 + 0))) : null; + if (_len1468) deallocate ~= cast()_ptr1468; + auto _list1469 = WitString(_ptr1468[0.._len1468]); + _elem1467 = _list1469; + } + if (_listLen1470) deallocate ~= _listSrcPtr1470; + auto _witList1471 = WitList!(WitString)(_list1470); + wit.pumpkin.plugin.java_packets.common.ConfigCRegistryData _record1472 = { + registryId: _list1466, + entries: _witList1471, + }; + auto _payload2563 = _record1472; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.configCRegistryData(_payload2563); + break; + } + case _Tag2551.configCConfigRemoveResourcePack: { + Option!(wit.pumpkin.plugin.java_packets.common.Uuid) _option1477 = void; + bool _isSome1477 = (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0; + if (_isSome1477) { + wit.pumpkin.plugin.uuid.common.Uuid _record1476 = { + high: *(cast(ulong*)(arg0 + 48)), + low: *(cast(ulong*)(arg0 + 56)), + }; + + _option1477 = Option!(wit.pumpkin.plugin.java_packets.common.Uuid).makeSome(_record1476); + } else { + _option1477 = Option!(wit.pumpkin.plugin.java_packets.common.Uuid).makeNone; + } + wit.pumpkin.plugin.java_packets.common.ConfigCConfigRemoveResourcePack _record1478 = { + uuid: _option1477, + }; + auto _payload2564 = _record1478; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.configCConfigRemoveResourcePack(_payload2564); + break; + } + case _Tag2551.configCConfigResetChat: { + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.configCConfigResetChat(); + break; + } + case _Tag2551.configCConfigServerLinks: { + auto _listSrcPtr1484 = *(cast(void**)(arg0 + 40)); + auto _listLen1484 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _list1484 = _listLen1484 ? wit.common.mallocSlice!(WitString)(_listLen1484) : []; + assert(!_listLen1484 || _list1484.ptr); + if (_listLen1484) deallocate ~= cast(void*)_list1484.ptr; + foreach (_elem1481_idx, ref _elem1481; _list1484) { + const auto _base1481 = _listSrcPtr1484 + _elem1481_idx * (2*size_t.sizeof); + auto _len1482 = *(cast(size_t*)(_base1481 + size_t.sizeof)); + auto _ptr1482 = _len1482 ? cast(char*)(*(cast(void**)(_base1481 + 0))) : null; + if (_len1482) deallocate ~= cast()_ptr1482; + auto _list1483 = WitString(_ptr1482[0.._len1482]); + _elem1481 = _list1483; + } + if (_listLen1484) deallocate ~= _listSrcPtr1484; + auto _witList1485 = WitList!(WitString)(_list1484); + wit.pumpkin.plugin.java_packets.common.ConfigCConfigServerLinks _record1486 = { + links: _witList1485, + }; + auto _payload2566 = _record1486; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.configCConfigServerLinks(_payload2566); + break; + } + case _Tag2551.configCConfigShowDialog: { + auto _len1488 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr1488 = _len1488 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len1488) deallocate ~= cast()_ptr1488; + auto _list1489 = WitString(_ptr1488[0.._len1488]); + wit.pumpkin.plugin.java_packets.common.ConfigCConfigShowDialog _record1490 = { + dialog: _list1489, + }; + auto _payload2567 = _record1490; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.configCConfigShowDialog(_payload2567); + break; + } + case _Tag2551.configCStoreCookie: { + auto _len1492 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr1492 = _len1492 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len1492) deallocate ~= cast()_ptr1492; + auto _list1493 = WitString(_ptr1492[0.._len1492]); + auto _len1494 = *(cast(size_t*)(arg0 + (40+3*size_t.sizeof))); + auto _ptr1494 = _len1494 ? cast(ubyte*)(*(cast(void**)(arg0 + (40+2*size_t.sizeof)))) : null; + if (_len1494) deallocate ~= cast()_ptr1494; + auto _list1495 = WitList!(ubyte)(_ptr1494[0.._len1494]); + wit.pumpkin.plugin.java_packets.common.ConfigCStoreCookie _record1496 = { + key: _list1493, + payload: _list1495, + }; + auto _payload2568 = _record1496; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.configCStoreCookie(_payload2568); + break; + } + case _Tag2551.configCTransfer: { + auto _len1498 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr1498 = _len1498 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len1498) deallocate ~= cast()_ptr1498; + auto _list1499 = WitString(_ptr1498[0.._len1498]); + wit.pumpkin.plugin.java_packets.common.ConfigCTransfer _record1500 = { + host: _list1499, + port: cast(int)(*(cast(uint*)(arg0 + (40+2*size_t.sizeof)))), + }; + auto _payload2569 = _record1500; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.configCTransfer(_payload2569); + break; + } + case _Tag2551.configCUpdateTags: { + auto _listSrcPtr1505 = *(cast(void**)(arg0 + 40)); + auto _listLen1505 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _list1505 = _listLen1505 ? wit.common.mallocSlice!(WitString)(_listLen1505) : []; + assert(!_listLen1505 || _list1505.ptr); + if (_listLen1505) deallocate ~= cast(void*)_list1505.ptr; + foreach (_elem1502_idx, ref _elem1502; _list1505) { + const auto _base1502 = _listSrcPtr1505 + _elem1502_idx * (2*size_t.sizeof); + auto _len1503 = *(cast(size_t*)(_base1502 + size_t.sizeof)); + auto _ptr1503 = _len1503 ? cast(char*)(*(cast(void**)(_base1502 + 0))) : null; + if (_len1503) deallocate ~= cast()_ptr1503; + auto _list1504 = WitString(_ptr1503[0.._len1503]); + _elem1502 = _list1504; + } + if (_listLen1505) deallocate ~= _listSrcPtr1505; + auto _witList1506 = WitList!(WitString)(_list1505); + wit.pumpkin.plugin.java_packets.common.ConfigCUpdateTags _record1507 = { + tags: _witList1506, + }; + auto _payload2570 = _record1507; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.configCUpdateTags(_payload2570); + break; + } + case _Tag2551.loginCLoginCookieRequest: { + auto _len1509 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr1509 = _len1509 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len1509) deallocate ~= cast()_ptr1509; + auto _list1510 = WitString(_ptr1509[0.._len1509]); + wit.pumpkin.plugin.java_packets.common.LoginCLoginCookieRequest _record1511 = { + key: _list1510, + }; + auto _payload2571 = _record1511; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.loginCLoginCookieRequest(_payload2571); + break; + } + case _Tag2551.loginCLoginDisconnect: { + auto _len1513 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr1513 = _len1513 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len1513) deallocate ~= cast()_ptr1513; + auto _list1514 = WitString(_ptr1513[0.._len1513]); + wit.pumpkin.plugin.java_packets.common.LoginCLoginDisconnect _record1515 = { + jsonReason: _list1514, + }; + auto _payload2572 = _record1515; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.loginCLoginDisconnect(_payload2572); + break; + } + case _Tag2551.loginCLoginPluginRequest: { + auto _len1517 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _ptr1517 = _len1517 ? cast(char*)(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))) : null; + if (_len1517) deallocate ~= cast()_ptr1517; + auto _list1518 = WitString(_ptr1517[0.._len1517]); + auto _len1519 = *(cast(size_t*)(arg0 + (40+4*size_t.sizeof))); + auto _ptr1519 = _len1519 ? cast(ubyte*)(*(cast(void**)(arg0 + (40+3*size_t.sizeof)))) : null; + if (_len1519) deallocate ~= cast()_ptr1519; + auto _list1520 = WitList!(ubyte)(_ptr1519[0.._len1519]); + wit.pumpkin.plugin.java_packets.common.LoginCLoginPluginRequest _record1521 = { + messageId: cast(int)(*(cast(uint*)(arg0 + 40))), + channel: _list1518, + data: _list1520, + }; + auto _payload2573 = _record1521; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.loginCLoginPluginRequest(_payload2573); + break; + } + case _Tag2551.loginCSetCompression: { + wit.pumpkin.plugin.java_packets.common.LoginCSetCompression _record1523 = { + threshold: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload2574 = _record1523; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.loginCSetCompression(_payload2574); + break; + } + case _Tag2551.cAcknowledgeBlockChange: { + wit.pumpkin.plugin.java_packets.common.CAcknowledgeBlockChange _record1525 = { + sequenceId: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload2575 = _record1525; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cAcknowledgeBlockChange(_payload2575); + break; + } + case _Tag2551.cActionBar: { + auto _len1527 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr1527 = _len1527 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len1527) deallocate ~= cast()_ptr1527; + auto _list1528 = WitString(_ptr1527[0.._len1527]); + wit.pumpkin.plugin.java_packets.common.CActionBar _record1529 = { + actionBar: _list1528, + }; + auto _payload2576 = _record1529; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cActionBar(_payload2576); + break; + } + case _Tag2551.cAddResourcePack: { + wit.pumpkin.plugin.uuid.common.Uuid _record1531 = { + high: *(cast(ulong*)(arg0 + 40)), + low: *(cast(ulong*)(arg0 + 48)), + }; + auto _len1532 = *(cast(size_t*)(arg0 + (56+1*size_t.sizeof))); + auto _ptr1532 = _len1532 ? cast(char*)(*(cast(void**)(arg0 + 56))) : null; + if (_len1532) deallocate ~= cast()_ptr1532; + auto _list1533 = WitString(_ptr1532[0.._len1532]); + auto _len1534 = *(cast(size_t*)(arg0 + (56+3*size_t.sizeof))); + auto _ptr1534 = _len1534 ? cast(char*)(*(cast(void**)(arg0 + (56+2*size_t.sizeof)))) : null; + if (_len1534) deallocate ~= cast()_ptr1534; + auto _list1535 = WitString(_ptr1534[0.._len1534]); + Option!(WitString) _option1540 = void; + bool _isSome1540 = (cast(uint)(*(cast(ubyte*)(arg0 + (56+5*size_t.sizeof))))) != 0; + if (_isSome1540) { + auto _len1538 = *(cast(size_t*)(arg0 + (56+7*size_t.sizeof))); + auto _ptr1538 = _len1538 ? cast(char*)(*(cast(void**)(arg0 + (56+6*size_t.sizeof)))) : null; + if (_len1538) deallocate ~= cast()_ptr1538; + auto _list1539 = WitString(_ptr1538[0.._len1538]); + + _option1540 = Option!(WitString).makeSome(_list1539); + } else { + _option1540 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.java_packets.common.CAddResourcePack _record1541 = { + uuid: _record1531, + url: _list1533, + hash: _list1535, + forced: (cast(uint)(*(cast(ubyte*)(arg0 + (56+4*size_t.sizeof))))) != 0, + promptMessage: _option1540, + }; + auto _payload2577 = _record1541; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cAddResourcePack(_payload2577); + break; + } + case _Tag2551.cAwardStats: { + auto _len1543 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr1543 = _len1543 ? cast(wit.pumpkin.plugin.java_packets.common.Statistic*)(*(cast(void**)(arg0 + 40))) : null; + if (_len1543) deallocate ~= cast()_ptr1543; + auto _list1544 = WitList!(wit.pumpkin.plugin.java_packets.common.Statistic)(_ptr1543[0.._len1543]); + wit.pumpkin.plugin.java_packets.common.CAwardStats _record1545 = { + stats: _list1544, + }; + auto _payload2578 = _record1545; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cAwardStats(_payload2578); + break; + } + case _Tag2551.cSetBlockDestroyStage: { + auto _tuple1547 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + cast(int)(*(cast(uint*)(arg0 + 52))), + ); + wit.pumpkin.plugin.java_packets.common.CSetBlockDestroyStage _record1548 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + location: _tuple1547, + destroyStage: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 56)))), + }; + auto _payload2579 = _record1548; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSetBlockDestroyStage(_payload2579); + break; + } + case _Tag2551.cBlockEntityData: { + auto _tuple1550 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 40))), + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + ); + auto _len1551 = *(cast(size_t*)(arg0 + (56+1*size_t.sizeof))); + auto _ptr1551 = _len1551 ? cast(ubyte*)(*(cast(void**)(arg0 + 56))) : null; + if (_len1551) deallocate ~= cast()_ptr1551; + auto _list1552 = WitList!(ubyte)(_ptr1551[0.._len1551]); + wit.pumpkin.plugin.java_packets.common.CBlockEntityData _record1553 = { + location: _tuple1550, + rType: cast(int)(*(cast(uint*)(arg0 + 52))), + nbtData: _list1552, + }; + auto _payload2580 = _record1553; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cBlockEntityData(_payload2580); + break; + } + case _Tag2551.cBlockEvent: { + auto _tuple1555 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 40))), + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + ); + wit.pumpkin.plugin.java_packets.common.CBlockEvent _record1556 = { + location: _tuple1555, + actionId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 52)))), + actionParameter: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 53)))), + blockType: cast(int)(*(cast(uint*)(arg0 + 56))), + }; + auto _payload2581 = _record1556; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cBlockEvent(_payload2581); + break; + } + case _Tag2551.cBlockUpdate: { + auto _tuple1558 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 40))), + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + ); + wit.pumpkin.plugin.java_packets.common.CBlockUpdate _record1559 = { + location: _tuple1558, + stateId: cast(int)(*(cast(uint*)(arg0 + 52))), + }; + auto _payload2582 = _record1559; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cBlockUpdate(_payload2582); + break; + } + case _Tag2551.cBossEvent: { + wit.pumpkin.plugin.uuid.common.Uuid _record1561 = { + high: *(cast(ulong*)(arg0 + 40)), + low: *(cast(ulong*)(arg0 + 48)), + }; + wit.pumpkin.plugin.java_packets.common.BosseventAction _variant1574 = void; + auto _tag1574 = cast(uint)(*(cast(ubyte*)(arg0 + 56))); + alias _Tag1574 = wit.pumpkin.plugin.java_packets.common.BosseventAction.Tag; + final switch (cast(wit.pumpkin.plugin.java_packets.common.BosseventAction.Tag)_tag1574) { + case _Tag1574.add: { + auto _len1563 = *(cast(size_t*)(arg0 + (56+2*size_t.sizeof))); + auto _ptr1563 = _len1563 ? cast(char*)(*(cast(void**)(arg0 + (56+1*size_t.sizeof)))) : null; + if (_len1563) deallocate ~= cast()_ptr1563; + auto _list1564 = WitString(_ptr1563[0.._len1563]); + wit.pumpkin.plugin.java_packets.common.BosseventActionAdd _record1565 = { + title: _list1564, + health: *(cast(float*)(arg0 + (56+3*size_t.sizeof))), + color: cast(int)(*(cast(uint*)(arg0 + (60+3*size_t.sizeof)))), + division: cast(int)(*(cast(uint*)(arg0 + (64+3*size_t.sizeof)))), + flags: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (68+3*size_t.sizeof))))), + }; + auto _payload1575 = _record1565; + _variant1574 = wit.pumpkin.plugin.java_packets.common.BosseventAction.add(_payload1575); + break; + } + case _Tag1574.remove: { + _variant1574 = wit.pumpkin.plugin.java_packets.common.BosseventAction.remove(); + break; + } + case _Tag1574.updateHealth: { + auto _payload1577 = *(cast(float*)(arg0 + (56+1*size_t.sizeof))); + _variant1574 = wit.pumpkin.plugin.java_packets.common.BosseventAction.updateHealth(_payload1577); + break; + } + case _Tag1574.updateTile: { + auto _len1569 = *(cast(size_t*)(arg0 + (56+2*size_t.sizeof))); + auto _ptr1569 = _len1569 ? cast(char*)(*(cast(void**)(arg0 + (56+1*size_t.sizeof)))) : null; + if (_len1569) deallocate ~= cast()_ptr1569; + auto _list1570 = WitString(_ptr1569[0.._len1569]); + auto _payload1578 = _list1570; + _variant1574 = wit.pumpkin.plugin.java_packets.common.BosseventAction.updateTile(_payload1578); + break; + } + case _Tag1574.updateStyle: { + wit.pumpkin.plugin.java_packets.common.BosseventActionUpdateStyle _record1572 = { + color: cast(int)(*(cast(uint*)(arg0 + (56+1*size_t.sizeof)))), + dividers: cast(int)(*(cast(uint*)(arg0 + (60+1*size_t.sizeof)))), + }; + auto _payload1579 = _record1572; + _variant1574 = wit.pumpkin.plugin.java_packets.common.BosseventAction.updateStyle(_payload1579); + break; + } + case _Tag1574.updateFlags: { + auto _payload1580 = cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (56+1*size_t.sizeof))))); + _variant1574 = wit.pumpkin.plugin.java_packets.common.BosseventAction.updateFlags(_payload1580); + break; + } + } + wit.pumpkin.plugin.java_packets.common.CBossEvent _record1581 = { + uuid: _record1561, + action: _variant1574, + }; + auto _payload2583 = _record1581; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cBossEvent(_payload2583); + break; + } + case _Tag2551.cBundleDelimiter: { + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cBundleDelimiter(); + break; + } + case _Tag2551.cCenterChunk: { + wit.pumpkin.plugin.java_packets.common.CCenterChunk _record1584 = { + chunkX: cast(int)(*(cast(uint*)(arg0 + 40))), + chunkZ: cast(int)(*(cast(uint*)(arg0 + 44))), + }; + auto _payload2585 = _record1584; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cCenterChunk(_payload2585); + break; + } + case _Tag2551.cChangeDifficulty: { + wit.pumpkin.plugin.java_packets.common.CChangeDifficulty _record1586 = { + difficulty: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 40)))), + locked: (cast(uint)(*(cast(ubyte*)(arg0 + 41)))) != 0, + }; + auto _payload2586 = _record1586; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cChangeDifficulty(_payload2586); + break; + } + case _Tag2551.cChunkBatchEnd: { + wit.pumpkin.plugin.java_packets.common.CChunkBatchEnd _record1588 = { + batchSize: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload2587 = _record1588; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cChunkBatchEnd(_payload2587); + break; + } + case _Tag2551.cChunkBatchStart: { + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cChunkBatchStart(); + break; + } + case _Tag2551.cChunksBiomes: { + auto _listSrcPtr1595 = *(cast(void**)(arg0 + 40)); + auto _listLen1595 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _list1595 = _listLen1595 ? wit.common.mallocSlice!(wit.pumpkin.plugin.java_packets.common.ChunkBiomeEntry)(_listLen1595) : []; + assert(!_listLen1595 || _list1595.ptr); + if (_listLen1595) deallocate ~= cast(void*)_list1595.ptr; + foreach (_elem1591_idx, ref _elem1591; _list1595) { + const auto _base1591 = _listSrcPtr1595 + _elem1591_idx * (8+2*size_t.sizeof); + auto _len1592 = *(cast(size_t*)(_base1591 + (8+1*size_t.sizeof))); + auto _ptr1592 = _len1592 ? cast(ubyte*)(*(cast(void**)(_base1591 + 8))) : null; + if (_len1592) deallocate ~= cast()_ptr1592; + auto _list1593 = WitList!(ubyte)(_ptr1592[0.._len1592]); + wit.pumpkin.plugin.java_packets.common.ChunkBiomeEntry _record1594 = { + chunkX: cast(int)(*(cast(uint*)(_base1591 + 0))), + chunkZ: cast(int)(*(cast(uint*)(_base1591 + 4))), + data: _list1593, + }; + _elem1591 = _record1594; + } + if (_listLen1595) deallocate ~= _listSrcPtr1595; + auto _witList1596 = WitList!(wit.pumpkin.plugin.java_packets.common.ChunkBiomeEntry)(_list1595); + wit.pumpkin.plugin.java_packets.common.CChunksBiomes _record1597 = { + chunks: _witList1596, + }; + auto _payload2589 = _record1597; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cChunksBiomes(_payload2589); + break; + } + case _Tag2551.cPlayClearDialog: { + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cPlayClearDialog(); + break; + } + case _Tag2551.cClearTitle: { + wit.pumpkin.plugin.java_packets.common.CClearTitle _record1600 = { + reset: (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0, + }; + auto _payload2591 = _record1600; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cClearTitle(_payload2591); + break; + } + case _Tag2551.cCloseContainer: { + wit.pumpkin.plugin.java_packets.common.CCloseContainer _record1602 = { + syncId: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload2592 = _record1602; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cCloseContainer(_payload2592); + break; + } + case _Tag2551.cCombatDeath: { + auto _len1604 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _ptr1604 = _len1604 ? cast(char*)(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))) : null; + if (_len1604) deallocate ~= cast()_ptr1604; + auto _list1605 = WitString(_ptr1604[0.._len1604]); + wit.pumpkin.plugin.java_packets.common.CCombatDeath _record1606 = { + playerId: cast(int)(*(cast(uint*)(arg0 + 40))), + message: _list1605, + }; + auto _payload2593 = _record1606; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cCombatDeath(_payload2593); + break; + } + case _Tag2551.cCombatEnter: { + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cCombatEnter(); + break; + } + case _Tag2551.cCombatEnd: { + wit.pumpkin.plugin.java_packets.common.CCombatEnd _record1609 = { + durationTicks: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload2595 = _record1609; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cCombatEnd(_payload2595); + break; + } + case _Tag2551.cCommandSuggestions: { + auto _listSrcPtr1620 = *(cast(void**)(arg0 + (48+1*size_t.sizeof))); + auto _listLen1620 = *(cast(size_t*)(arg0 + (48+2*size_t.sizeof))); + auto _list1620 = _listLen1620 ? wit.common.mallocSlice!(wit.pumpkin.plugin.java_packets.common.CommandSuggestion)(_listLen1620) : []; + assert(!_listLen1620 || _list1620.ptr); + if (_listLen1620) deallocate ~= cast(void*)_list1620.ptr; + foreach (_elem1611_idx, ref _elem1611; _list1620) { + const auto _base1611 = _listSrcPtr1620 + _elem1611_idx * (5*size_t.sizeof); + auto _len1612 = *(cast(size_t*)(_base1611 + size_t.sizeof)); + auto _ptr1612 = _len1612 ? cast(char*)(*(cast(void**)(_base1611 + 0))) : null; + if (_len1612) deallocate ~= cast()_ptr1612; + auto _list1613 = WitString(_ptr1612[0.._len1612]); + Option!(WitString) _option1618 = void; + bool _isSome1618 = (cast(uint)(*(cast(ubyte*)(_base1611 + (2*size_t.sizeof))))) != 0; + if (_isSome1618) { + auto _len1616 = *(cast(size_t*)(_base1611 + (4*size_t.sizeof))); + auto _ptr1616 = _len1616 ? cast(char*)(*(cast(void**)(_base1611 + (3*size_t.sizeof)))) : null; + if (_len1616) deallocate ~= cast()_ptr1616; + auto _list1617 = WitString(_ptr1616[0.._len1616]); + + _option1618 = Option!(WitString).makeSome(_list1617); + } else { + _option1618 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.java_packets.common.CommandSuggestion _record1619 = { + suggestion: _list1613, + tooltip: _option1618, + }; + _elem1611 = _record1619; + } + if (_listLen1620) deallocate ~= _listSrcPtr1620; + auto _witList1621 = WitList!(wit.pumpkin.plugin.java_packets.common.CommandSuggestion)(_list1620); + wit.pumpkin.plugin.java_packets.common.CCommandSuggestions _record1622 = { + id: cast(int)(*(cast(uint*)(arg0 + 40))), + start: cast(int)(*(cast(uint*)(arg0 + 44))), + length: cast(int)(*(cast(uint*)(arg0 + 48))), + matches: _witList1621, + }; + auto _payload2596 = _record1622; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cCommandSuggestions(_payload2596); + break; + } + case _Tag2551.cCommands: { + auto _listSrcPtr1808 = *(cast(void**)(arg0 + 40)); + auto _listLen1808 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _list1808 = _listLen1808 ? wit.common.mallocSlice!(wit.pumpkin.plugin.java_packets.common.ProtoNode)(_listLen1808) : []; + assert(!_listLen1808 || _list1808.ptr); + if (_listLen1808) deallocate ~= cast(void*)_list1808.ptr; + foreach (_elem1624_idx, ref _elem1624; _list1808) { + const auto _base1624 = _listSrcPtr1808 + _elem1624_idx * (72+4*size_t.sizeof); + auto _len1625 = *(cast(size_t*)(_base1624 + size_t.sizeof)); + auto _ptr1625 = _len1625 ? cast(int*)(*(cast(void**)(_base1624 + 0))) : null; + if (_len1625) deallocate ~= cast()_ptr1625; + auto _list1626 = WitList!(int)(_ptr1625[0.._len1625]); + wit.pumpkin.plugin.java_packets.common.ProtoNodeType _variant1803 = void; + auto _tag1803 = cast(uint)(*(cast(ubyte*)(_base1624 + (2*size_t.sizeof)))); + alias _Tag1803 = wit.pumpkin.plugin.java_packets.common.ProtoNodeType.Tag; + final switch (cast(wit.pumpkin.plugin.java_packets.common.ProtoNodeType.Tag)_tag1803) { + case _Tag1803.root: { + _variant1803 = wit.pumpkin.plugin.java_packets.common.ProtoNodeType.root(); + break; + } + case _Tag1803.literal: { + auto _len1629 = *(cast(size_t*)(_base1624 + (8+3*size_t.sizeof))); + auto _ptr1629 = _len1629 ? cast(char*)(*(cast(void**)(_base1624 + (8+2*size_t.sizeof)))) : null; + if (_len1629) deallocate ~= cast()_ptr1629; + auto _list1630 = WitString(_ptr1629[0.._len1629]); + Option!(int) _option1633 = void; + bool _isSome1633 = (cast(uint)(*(cast(ubyte*)(_base1624 + (12+4*size_t.sizeof))))) != 0; + if (_isSome1633) { + + _option1633 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base1624 + (16+4*size_t.sizeof))))); + } else { + _option1633 = Option!(int).makeNone; + } + wit.pumpkin.plugin.java_packets.common.ProtoNodeTypeLiteral _record1634 = { + name: _list1630, + isExecutable: (cast(uint)(*(cast(ubyte*)(_base1624 + (8+4*size_t.sizeof))))) != 0, + redirectTarget: _option1633, + restricted: (cast(uint)(*(cast(ubyte*)(_base1624 + (20+4*size_t.sizeof))))) != 0, + }; + auto _payload1805 = _record1634; + _variant1803 = wit.pumpkin.plugin.java_packets.common.ProtoNodeType.literal(_payload1805); + break; + } + case _Tag1803.argument: { + auto _len1636 = *(cast(size_t*)(_base1624 + (8+3*size_t.sizeof))); + auto _ptr1636 = _len1636 ? cast(char*)(*(cast(void**)(_base1624 + (8+2*size_t.sizeof)))) : null; + if (_len1636) deallocate ~= cast()_ptr1636; + auto _list1637 = WitString(_ptr1636[0.._len1636]); + Option!(int) _option1640 = void; + bool _isSome1640 = (cast(uint)(*(cast(ubyte*)(_base1624 + (12+4*size_t.sizeof))))) != 0; + if (_isSome1640) { + + _option1640 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base1624 + (16+4*size_t.sizeof))))); + } else { + _option1640 = Option!(int).makeNone; + } + wit.pumpkin.plugin.java_packets.common.ArgumentType _variant1741 = void; + auto _tag1741 = cast(uint)(*(cast(ubyte*)(_base1624 + (24+4*size_t.sizeof)))); + alias _Tag1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.Tag; + final switch (cast(wit.pumpkin.plugin.java_packets.common.ArgumentType.Tag)_tag1741) { + case _Tag1741.bool_: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.bool_(); + break; + } + case _Tag1741.float_: { + Option!(float) _option1645 = void; + bool _isSome1645 = (cast(uint)(*(cast(ubyte*)(_base1624 + (32+4*size_t.sizeof))))) != 0; + if (_isSome1645) { + + _option1645 = Option!(float).makeSome(*(cast(float*)(_base1624 + (36+4*size_t.sizeof)))); + } else { + _option1645 = Option!(float).makeNone; + } + Option!(float) _option1648 = void; + bool _isSome1648 = (cast(uint)(*(cast(ubyte*)(_base1624 + (40+4*size_t.sizeof))))) != 0; + if (_isSome1648) { + + _option1648 = Option!(float).makeSome(*(cast(float*)(_base1624 + (44+4*size_t.sizeof)))); + } else { + _option1648 = Option!(float).makeNone; + } + wit.pumpkin.plugin.java_packets.common.ArgumentTypeFloat _record1649 = { + min: _option1645, + max: _option1648, + }; + auto _payload1743 = _record1649; + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.float_(_payload1743); + break; + } + case _Tag1741.double_: { + Option!(double) _option1653 = void; + bool _isSome1653 = (cast(uint)(*(cast(ubyte*)(_base1624 + (32+4*size_t.sizeof))))) != 0; + if (_isSome1653) { + + _option1653 = Option!(double).makeSome(*(cast(double*)(_base1624 + (40+4*size_t.sizeof)))); + } else { + _option1653 = Option!(double).makeNone; + } + Option!(double) _option1656 = void; + bool _isSome1656 = (cast(uint)(*(cast(ubyte*)(_base1624 + (48+4*size_t.sizeof))))) != 0; + if (_isSome1656) { + + _option1656 = Option!(double).makeSome(*(cast(double*)(_base1624 + (56+4*size_t.sizeof)))); + } else { + _option1656 = Option!(double).makeNone; + } + wit.pumpkin.plugin.java_packets.common.ArgumentTypeDouble _record1657 = { + min: _option1653, + max: _option1656, + }; + auto _payload1744 = _record1657; + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.double_(_payload1744); + break; + } + case _Tag1741.integer: { + Option!(int) _option1661 = void; + bool _isSome1661 = (cast(uint)(*(cast(ubyte*)(_base1624 + (32+4*size_t.sizeof))))) != 0; + if (_isSome1661) { + + _option1661 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base1624 + (36+4*size_t.sizeof))))); + } else { + _option1661 = Option!(int).makeNone; + } + Option!(int) _option1664 = void; + bool _isSome1664 = (cast(uint)(*(cast(ubyte*)(_base1624 + (40+4*size_t.sizeof))))) != 0; + if (_isSome1664) { + + _option1664 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base1624 + (44+4*size_t.sizeof))))); + } else { + _option1664 = Option!(int).makeNone; + } + wit.pumpkin.plugin.java_packets.common.ArgumentTypeInteger _record1665 = { + min: _option1661, + max: _option1664, + }; + auto _payload1745 = _record1665; + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.integer(_payload1745); + break; + } + case _Tag1741.long_: { + Option!(long) _option1669 = void; + bool _isSome1669 = (cast(uint)(*(cast(ubyte*)(_base1624 + (32+4*size_t.sizeof))))) != 0; + if (_isSome1669) { + + _option1669 = Option!(long).makeSome(cast(long)(*(cast(ulong*)(_base1624 + (40+4*size_t.sizeof))))); + } else { + _option1669 = Option!(long).makeNone; + } + Option!(long) _option1672 = void; + bool _isSome1672 = (cast(uint)(*(cast(ubyte*)(_base1624 + (48+4*size_t.sizeof))))) != 0; + if (_isSome1672) { + + _option1672 = Option!(long).makeSome(cast(long)(*(cast(ulong*)(_base1624 + (56+4*size_t.sizeof))))); + } else { + _option1672 = Option!(long).makeNone; + } + wit.pumpkin.plugin.java_packets.common.ArgumentTypeLong _record1673 = { + min: _option1669, + max: _option1672, + }; + auto _payload1746 = _record1673; + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.long_(_payload1746); + break; + } + case _Tag1741.string: { + auto _payload1747 = cast(wit.pumpkin.plugin.java_packets.common.StringProtoArgBehavior)(cast(uint)(*(cast(ubyte*)(_base1624 + (32+4*size_t.sizeof))))); + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.string(_payload1747); + break; + } + case _Tag1741.entity: { + wit.pumpkin.plugin.java_packets.common.ArgumentTypeEntity _record1676 = { + flags: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1624 + (32+4*size_t.sizeof))))), + }; + auto _payload1748 = _record1676; + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.entity(_payload1748); + break; + } + case _Tag1741.gameProfile: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.gameProfile(); + break; + } + case _Tag1741.blockPos: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.blockPos(); + break; + } + case _Tag1741.columnPos: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.columnPos(); + break; + } + case _Tag1741.vec3: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.vec3(); + break; + } + case _Tag1741.vec2: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.vec2(); + break; + } + case _Tag1741.blockState: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.blockState(); + break; + } + case _Tag1741.blockPredicate: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.blockPredicate(); + break; + } + case _Tag1741.itemStack: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.itemStack(); + break; + } + case _Tag1741.itemPredicate: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.itemPredicate(); + break; + } + case _Tag1741.color: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.color(); + break; + } + case _Tag1741.hexColor: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.hexColor(); + break; + } + case _Tag1741.component: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.component(); + break; + } + case _Tag1741.style: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.style(); + break; + } + case _Tag1741.message: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.message(); + break; + } + case _Tag1741.nbtCompound: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.nbtCompound(); + break; + } + case _Tag1741.nbtTag: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.nbtTag(); + break; + } + case _Tag1741.nbtPath: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.nbtPath(); + break; + } + case _Tag1741.objective: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.objective(); + break; + } + case _Tag1741.objectiveCriteria: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.objectiveCriteria(); + break; + } + case _Tag1741.operation: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.operation(); + break; + } + case _Tag1741.particle: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.particle(); + break; + } + case _Tag1741.angle: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.angle(); + break; + } + case _Tag1741.rotation: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.rotation(); + break; + } + case _Tag1741.scoreboardSlot: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.scoreboardSlot(); + break; + } + case _Tag1741.scoreHolder: { + wit.pumpkin.plugin.java_packets.common.ArgumentTypeScoreHolder _record1702 = { + flags: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1624 + (32+4*size_t.sizeof))))), + }; + auto _payload1773 = _record1702; + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.scoreHolder(_payload1773); + break; + } + case _Tag1741.swizzle: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.swizzle(); + break; + } + case _Tag1741.team: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.team(); + break; + } + case _Tag1741.itemSlot: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.itemSlot(); + break; + } + case _Tag1741.itemSlots: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.itemSlots(); + break; + } + case _Tag1741.resourceLocation: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.resourceLocation(); + break; + } + case _Tag1741.function_: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.function_(); + break; + } + case _Tag1741.entityAnchor: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.entityAnchor(); + break; + } + case _Tag1741.intRange: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.intRange(); + break; + } + case _Tag1741.floatRange: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.floatRange(); + break; + } + case _Tag1741.dimension: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.dimension(); + break; + } + case _Tag1741.gamemode: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.gamemode(); + break; + } + case _Tag1741.time: { + wit.pumpkin.plugin.java_packets.common.ArgumentTypeTime _record1715 = { + min: cast(int)(*(cast(uint*)(_base1624 + (32+4*size_t.sizeof)))), + }; + auto _payload1785 = _record1715; + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.time(_payload1785); + break; + } + case _Tag1741.resourceOrTag: { + auto _len1717 = *(cast(size_t*)(_base1624 + (32+5*size_t.sizeof))); + auto _ptr1717 = _len1717 ? cast(char*)(*(cast(void**)(_base1624 + (32+4*size_t.sizeof)))) : null; + if (_len1717) deallocate ~= cast()_ptr1717; + auto _list1718 = WitString(_ptr1717[0.._len1717]); + wit.pumpkin.plugin.java_packets.common.ArgumentTypeResourceOrTag _record1719 = { + identifier: _list1718, + }; + auto _payload1786 = _record1719; + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.resourceOrTag(_payload1786); + break; + } + case _Tag1741.resourceOrTagKey: { + auto _len1721 = *(cast(size_t*)(_base1624 + (32+5*size_t.sizeof))); + auto _ptr1721 = _len1721 ? cast(char*)(*(cast(void**)(_base1624 + (32+4*size_t.sizeof)))) : null; + if (_len1721) deallocate ~= cast()_ptr1721; + auto _list1722 = WitString(_ptr1721[0.._len1721]); + wit.pumpkin.plugin.java_packets.common.ArgumentTypeResourceOrTagKey _record1723 = { + identifier: _list1722, + }; + auto _payload1787 = _record1723; + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.resourceOrTagKey(_payload1787); + break; + } + case _Tag1741.resource: { + auto _len1725 = *(cast(size_t*)(_base1624 + (32+5*size_t.sizeof))); + auto _ptr1725 = _len1725 ? cast(char*)(*(cast(void**)(_base1624 + (32+4*size_t.sizeof)))) : null; + if (_len1725) deallocate ~= cast()_ptr1725; + auto _list1726 = WitString(_ptr1725[0.._len1725]); + wit.pumpkin.plugin.java_packets.common.ArgumentTypeResource _record1727 = { + identifier: _list1726, + }; + auto _payload1788 = _record1727; + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.resource(_payload1788); + break; + } + case _Tag1741.resourceKey: { + auto _len1729 = *(cast(size_t*)(_base1624 + (32+5*size_t.sizeof))); + auto _ptr1729 = _len1729 ? cast(char*)(*(cast(void**)(_base1624 + (32+4*size_t.sizeof)))) : null; + if (_len1729) deallocate ~= cast()_ptr1729; + auto _list1730 = WitString(_ptr1729[0.._len1729]); + wit.pumpkin.plugin.java_packets.common.ArgumentTypeResourceKey _record1731 = { + identifier: _list1730, + }; + auto _payload1789 = _record1731; + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.resourceKey(_payload1789); + break; + } + case _Tag1741.resourceSelector: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.resourceSelector(); + break; + } + case _Tag1741.templateMirror: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.templateMirror(); + break; + } + case _Tag1741.templateRotation: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.templateRotation(); + break; + } + case _Tag1741.heightmap: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.heightmap(); + break; + } + case _Tag1741.lootTable: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.lootTable(); + break; + } + case _Tag1741.lootPredicate: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.lootPredicate(); + break; + } + case _Tag1741.lootModifier: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.lootModifier(); + break; + } + case _Tag1741.dialog: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.dialog(); + break; + } + case _Tag1741.uuid: { + _variant1741 = wit.pumpkin.plugin.java_packets.common.ArgumentType.uuid(); + break; + } + } + Option!(wit.pumpkin.plugin.java_packets.common.SuggestionProviders) _option1801 = void; + bool _isSome1801 = (cast(uint)(*(cast(ubyte*)(_base1624 + (64+4*size_t.sizeof))))) != 0; + if (_isSome1801) { + + _option1801 = Option!(wit.pumpkin.plugin.java_packets.common.SuggestionProviders).makeSome(cast(wit.pumpkin.plugin.java_packets.common.SuggestionProviders)(cast(uint)(*(cast(ubyte*)(_base1624 + (65+4*size_t.sizeof)))))); + } else { + _option1801 = Option!(wit.pumpkin.plugin.java_packets.common.SuggestionProviders).makeNone; + } + wit.pumpkin.plugin.java_packets.common.ProtoNodeTypeArgument _record1802 = { + name: _list1637, + isExecutable: (cast(uint)(*(cast(ubyte*)(_base1624 + (8+4*size_t.sizeof))))) != 0, + redirectTarget: _option1640, + parser: _variant1741, + overrideSuggestionType: _option1801, + restricted: (cast(uint)(*(cast(ubyte*)(_base1624 + (66+4*size_t.sizeof))))) != 0, + }; + auto _payload1806 = _record1802; + _variant1803 = wit.pumpkin.plugin.java_packets.common.ProtoNodeType.argument(_payload1806); + break; + } + } + wit.pumpkin.plugin.java_packets.common.ProtoNode _record1807 = { + children: _list1626, + nodeType: _variant1803, + }; + _elem1624 = _record1807; + } + if (_listLen1808) deallocate ~= _listSrcPtr1808; + auto _witList1809 = WitList!(wit.pumpkin.plugin.java_packets.common.ProtoNode)(_list1808); + wit.pumpkin.plugin.java_packets.common.CCommands _record1810 = { + nodes: _witList1809, + rootNodeIndex: cast(int)(*(cast(uint*)(arg0 + (40+2*size_t.sizeof)))), + }; + auto _payload2597 = _record1810; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cCommands(_payload2597); + break; + } + case _Tag2551.cPlayCookieRequest: { + auto _len1812 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr1812 = _len1812 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len1812) deallocate ~= cast()_ptr1812; + auto _list1813 = WitString(_ptr1812[0.._len1812]); + wit.pumpkin.plugin.java_packets.common.CPlayCookieRequest _record1814 = { + key: _list1813, + }; + auto _payload2598 = _record1814; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cPlayCookieRequest(_payload2598); + break; + } + case _Tag2551.cCustomChatCompletions: { + auto _listSrcPtr1819 = *(cast(void**)(arg0 + (40+1*size_t.sizeof))); + auto _listLen1819 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _list1819 = _listLen1819 ? wit.common.mallocSlice!(WitString)(_listLen1819) : []; + assert(!_listLen1819 || _list1819.ptr); + if (_listLen1819) deallocate ~= cast(void*)_list1819.ptr; + foreach (_elem1816_idx, ref _elem1816; _list1819) { + const auto _base1816 = _listSrcPtr1819 + _elem1816_idx * (2*size_t.sizeof); + auto _len1817 = *(cast(size_t*)(_base1816 + size_t.sizeof)); + auto _ptr1817 = _len1817 ? cast(char*)(*(cast(void**)(_base1816 + 0))) : null; + if (_len1817) deallocate ~= cast()_ptr1817; + auto _list1818 = WitString(_ptr1817[0.._len1817]); + _elem1816 = _list1818; + } + if (_listLen1819) deallocate ~= _listSrcPtr1819; + auto _witList1820 = WitList!(WitString)(_list1819); + wit.pumpkin.plugin.java_packets.common.CCustomChatCompletions _record1821 = { + action: cast(int)(*(cast(uint*)(arg0 + 40))), + entries: _witList1820, + }; + auto _payload2599 = _record1821; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cCustomChatCompletions(_payload2599); + break; + } + case _Tag2551.cCustomPayload: { + auto _len1823 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr1823 = _len1823 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len1823) deallocate ~= cast()_ptr1823; + auto _list1824 = WitString(_ptr1823[0.._len1823]); + auto _len1825 = *(cast(size_t*)(arg0 + (40+3*size_t.sizeof))); + auto _ptr1825 = _len1825 ? cast(ubyte*)(*(cast(void**)(arg0 + (40+2*size_t.sizeof)))) : null; + if (_len1825) deallocate ~= cast()_ptr1825; + auto _list1826 = WitList!(ubyte)(_ptr1825[0.._len1825]); + wit.pumpkin.plugin.java_packets.common.CCustomPayload _record1827 = { + channel: _list1824, + data: _list1826, + }; + auto _payload2600 = _record1827; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cCustomPayload(_payload2600); + break; + } + case _Tag2551.cPlayCustomReportDetails: { + auto _listSrcPtr1835 = *(cast(void**)(arg0 + 40)); + auto _listLen1835 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _list1835 = _listLen1835 ? wit.common.mallocSlice!(Tuple!(WitString, WitString))(_listLen1835) : []; + assert(!_listLen1835 || _list1835.ptr); + if (_listLen1835) deallocate ~= cast(void*)_list1835.ptr; + foreach (_elem1829_idx, ref _elem1829; _list1835) { + const auto _base1829 = _listSrcPtr1835 + _elem1829_idx * (4*size_t.sizeof); + auto _len1830 = *(cast(size_t*)(_base1829 + size_t.sizeof)); + auto _ptr1830 = _len1830 ? cast(char*)(*(cast(void**)(_base1829 + 0))) : null; + if (_len1830) deallocate ~= cast()_ptr1830; + auto _list1831 = WitString(_ptr1830[0.._len1830]); + auto _len1832 = *(cast(size_t*)(_base1829 + (3*size_t.sizeof))); + auto _ptr1832 = _len1832 ? cast(char*)(*(cast(void**)(_base1829 + (2*size_t.sizeof)))) : null; + if (_len1832) deallocate ~= cast()_ptr1832; + auto _list1833 = WitString(_ptr1832[0.._len1832]); + auto _tuple1834 = Tuple!(WitString, WitString)( + _list1831, + _list1833, + ); + _elem1829 = _tuple1834; + } + if (_listLen1835) deallocate ~= _listSrcPtr1835; + auto _witList1836 = WitList!(Tuple!(WitString, WitString))(_list1835); + wit.pumpkin.plugin.java_packets.common.CPlayCustomReportDetails _record1837 = { + details: _witList1836, + }; + auto _payload2601 = _record1837; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cPlayCustomReportDetails(_payload2601); + break; + } + case _Tag2551.cDamageEvent: { + Option!(Tuple!(double, double, double)) _option1842 = void; + bool _isSome1842 = (cast(uint)(*(cast(ubyte*)(arg0 + 56)))) != 0; + if (_isSome1842) { + auto _tuple1841 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 64)), + *(cast(double*)(arg0 + 72)), + *(cast(double*)(arg0 + 80)), + ); + + _option1842 = Option!(Tuple!(double, double, double)).makeSome(_tuple1841); + } else { + _option1842 = Option!(Tuple!(double, double, double)).makeNone; + } + wit.pumpkin.plugin.java_packets.common.CDamageEvent _record1843 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + sourceTypeId: cast(int)(*(cast(uint*)(arg0 + 44))), + sourceCauseId: cast(int)(*(cast(uint*)(arg0 + 48))), + sourceDirectId: cast(int)(*(cast(uint*)(arg0 + 52))), + sourcePosition: _option1842, + }; + auto _payload2602 = _record1843; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cDamageEvent(_payload2602); + break; + } + case _Tag2551.cDebugBlockValue: { + auto _tuple1845 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 40))), + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + ); + auto _len1846 = *(cast(size_t*)(arg0 + (48+2*size_t.sizeof))); + auto _ptr1846 = _len1846 ? cast(char*)(*(cast(void**)(arg0 + (48+1*size_t.sizeof)))) : null; + if (_len1846) deallocate ~= cast()_ptr1846; + auto _list1847 = WitString(_ptr1846[0.._len1846]); + auto _len1848 = *(cast(size_t*)(arg0 + (48+4*size_t.sizeof))); + auto _ptr1848 = _len1848 ? cast(char*)(*(cast(void**)(arg0 + (48+3*size_t.sizeof)))) : null; + if (_len1848) deallocate ~= cast()_ptr1848; + auto _list1849 = WitString(_ptr1848[0.._len1848]); + wit.pumpkin.plugin.java_packets.common.CDebugBlockValue _record1850 = { + pos: _tuple1845, + name: _list1847, + value: _list1849, + }; + auto _payload2603 = _record1850; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cDebugBlockValue(_payload2603); + break; + } + case _Tag2551.cDebugChunkValue: { + auto _tuple1852 = Tuple!(double, double)( + *(cast(double*)(arg0 + 40)), + *(cast(double*)(arg0 + 48)), + ); + auto _len1853 = *(cast(size_t*)(arg0 + (56+1*size_t.sizeof))); + auto _ptr1853 = _len1853 ? cast(char*)(*(cast(void**)(arg0 + 56))) : null; + if (_len1853) deallocate ~= cast()_ptr1853; + auto _list1854 = WitString(_ptr1853[0.._len1853]); + auto _len1855 = *(cast(size_t*)(arg0 + (56+3*size_t.sizeof))); + auto _ptr1855 = _len1855 ? cast(char*)(*(cast(void**)(arg0 + (56+2*size_t.sizeof)))) : null; + if (_len1855) deallocate ~= cast()_ptr1855; + auto _list1856 = WitString(_ptr1855[0.._len1855]); + wit.pumpkin.plugin.java_packets.common.CDebugChunkValue _record1857 = { + chunkPos: _tuple1852, + name: _list1854, + value: _list1856, + }; + auto _payload2604 = _record1857; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cDebugChunkValue(_payload2604); + break; + } + case _Tag2551.cDebugEntityValue: { + auto _len1859 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _ptr1859 = _len1859 ? cast(char*)(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))) : null; + if (_len1859) deallocate ~= cast()_ptr1859; + auto _list1860 = WitString(_ptr1859[0.._len1859]); + auto _len1861 = *(cast(size_t*)(arg0 + (40+4*size_t.sizeof))); + auto _ptr1861 = _len1861 ? cast(char*)(*(cast(void**)(arg0 + (40+3*size_t.sizeof)))) : null; + if (_len1861) deallocate ~= cast()_ptr1861; + auto _list1862 = WitString(_ptr1861[0.._len1861]); + wit.pumpkin.plugin.java_packets.common.CDebugEntityValue _record1863 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + name: _list1860, + value: _list1862, + }; + auto _payload2605 = _record1863; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cDebugEntityValue(_payload2605); + break; + } + case _Tag2551.cDebugEvent: { + auto _len1865 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr1865 = _len1865 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len1865) deallocate ~= cast()_ptr1865; + auto _list1866 = WitString(_ptr1865[0.._len1865]); + auto _len1867 = *(cast(size_t*)(arg0 + (40+3*size_t.sizeof))); + auto _ptr1867 = _len1867 ? cast(ubyte*)(*(cast(void**)(arg0 + (40+2*size_t.sizeof)))) : null; + if (_len1867) deallocate ~= cast()_ptr1867; + auto _list1868 = WitList!(ubyte)(_ptr1867[0.._len1867]); + wit.pumpkin.plugin.java_packets.common.CDebugEvent _record1869 = { + name: _list1866, + data: _list1868, + }; + auto _payload2606 = _record1869; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cDebugEvent(_payload2606); + break; + } + case _Tag2551.cDebugSample: { + auto _len1871 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr1871 = _len1871 ? cast(long*)(*(cast(void**)(arg0 + 40))) : null; + if (_len1871) deallocate ~= cast()_ptr1871; + auto _list1872 = WitList!(long)(_ptr1871[0.._len1871]); + wit.pumpkin.plugin.java_packets.common.CDebugSample _record1873 = { + sample: _list1872, + sampleType: cast(int)(*(cast(uint*)(arg0 + (40+2*size_t.sizeof)))), + }; + auto _payload2607 = _record1873; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cDebugSample(_payload2607); + break; + } + case _Tag2551.cDeleteChat: { + Option!(WitList!(ubyte)) _option1879 = void; + bool _isSome1879 = (cast(uint)(*(cast(ubyte*)(arg0 + (40+1*size_t.sizeof))))) != 0; + if (_isSome1879) { + auto _len1877 = *(cast(size_t*)(arg0 + (40+3*size_t.sizeof))); + auto _ptr1877 = _len1877 ? cast(ubyte*)(*(cast(void**)(arg0 + (40+2*size_t.sizeof)))) : null; + if (_len1877) deallocate ~= cast()_ptr1877; + auto _list1878 = WitList!(ubyte)(_ptr1877[0.._len1877]); + + _option1879 = Option!(WitList!(ubyte)).makeSome(_list1878); + } else { + _option1879 = Option!(WitList!(ubyte)).makeNone; + } + wit.pumpkin.plugin.java_packets.common.CDeleteChat _record1880 = { + signatureId: cast(int)(*(cast(uint*)(arg0 + 40))), + signature: _option1879, + }; + auto _payload2608 = _record1880; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cDeleteChat(_payload2608); + break; + } + case _Tag2551.cPlayDisconnect: { + auto _len1882 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr1882 = _len1882 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len1882) deallocate ~= cast()_ptr1882; + auto _list1883 = WitString(_ptr1882[0.._len1882]); + wit.pumpkin.plugin.java_packets.common.CPlayDisconnect _record1884 = { + reason: _list1883, + }; + auto _payload2609 = _record1884; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cPlayDisconnect(_payload2609); + break; + } + case _Tag2551.cDisguisedChatMessage: { + auto _len1886 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr1886 = _len1886 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len1886) deallocate ~= cast()_ptr1886; + auto _list1887 = WitString(_ptr1886[0.._len1886]); + auto _len1888 = *(cast(size_t*)(arg0 + (40+4*size_t.sizeof))); + auto _ptr1888 = _len1888 ? cast(char*)(*(cast(void**)(arg0 + (40+3*size_t.sizeof)))) : null; + if (_len1888) deallocate ~= cast()_ptr1888; + auto _list1889 = WitString(_ptr1888[0.._len1888]); + Option!(WitString) _option1894 = void; + bool _isSome1894 = (cast(uint)(*(cast(ubyte*)(arg0 + (40+5*size_t.sizeof))))) != 0; + if (_isSome1894) { + auto _len1892 = *(cast(size_t*)(arg0 + (40+7*size_t.sizeof))); + auto _ptr1892 = _len1892 ? cast(char*)(*(cast(void**)(arg0 + (40+6*size_t.sizeof)))) : null; + if (_len1892) deallocate ~= cast()_ptr1892; + auto _list1893 = WitString(_ptr1892[0.._len1892]); + + _option1894 = Option!(WitString).makeSome(_list1893); + } else { + _option1894 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.java_packets.common.CDisguisedChatMessage _record1895 = { + message: _list1887, + chatType: cast(int)(*(cast(uint*)(arg0 + (40+2*size_t.sizeof)))), + senderName: _list1889, + targetName: _option1894, + }; + auto _payload2610 = _record1895; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cDisguisedChatMessage(_payload2610); + break; + } + case _Tag2551.cDisplayObjective: { + auto _len1897 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _ptr1897 = _len1897 ? cast(char*)(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))) : null; + if (_len1897) deallocate ~= cast()_ptr1897; + auto _list1898 = WitString(_ptr1897[0.._len1897]); + wit.pumpkin.plugin.java_packets.common.CDisplayObjective _record1899 = { + position: cast(int)(*(cast(uint*)(arg0 + 40))), + scoreName: _list1898, + }; + auto _payload2611 = _record1899; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cDisplayObjective(_payload2611); + break; + } + case _Tag2551.cEntityAnimation: { + wit.pumpkin.plugin.java_packets.common.CEntityAnimation _record1901 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + animation: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 44)))), + }; + auto _payload2612 = _record1901; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cEntityAnimation(_payload2612); + break; + } + case _Tag2551.cSetEntityMetadata: { + auto _len1903 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _ptr1903 = _len1903 ? cast(ubyte*)(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))) : null; + if (_len1903) deallocate ~= cast()_ptr1903; + auto _list1904 = WitList!(ubyte)(_ptr1903[0.._len1903]); + wit.pumpkin.plugin.java_packets.common.CSetEntityMetadata _record1905 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + metadata: _list1904, + }; + auto _payload2613 = _record1905; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSetEntityMetadata(_payload2613); + break; + } + case _Tag2551.cEntitySoundEffect: { + auto _len1907 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr1907 = _len1907 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len1907) deallocate ~= cast()_ptr1907; + auto _list1908 = WitString(_ptr1907[0.._len1907]); + wit.pumpkin.plugin.java_packets.common.CEntitySoundEffect _record1909 = { + soundEvent: _list1908, + soundCategory: cast(int)(*(cast(uint*)(arg0 + (40+2*size_t.sizeof)))), + entityId: cast(int)(*(cast(uint*)(arg0 + (44+2*size_t.sizeof)))), + volume: *(cast(float*)(arg0 + (48+2*size_t.sizeof))), + pitch: *(cast(float*)(arg0 + (52+2*size_t.sizeof))), + seed: cast(long)(*(cast(ulong*)(arg0 + (56+2*size_t.sizeof)))), + }; + auto _payload2614 = _record1909; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cEntitySoundEffect(_payload2614); + break; + } + case _Tag2551.cEntityStatus: { + wit.pumpkin.plugin.java_packets.common.CEntityStatus _record1911 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + entityStatus: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 44)))), + }; + auto _payload2615 = _record1911; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cEntityStatus(_payload2615); + break; + } + case _Tag2551.cEntityVelocity: { + auto _len1913 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _ptr1913 = _len1913 ? cast(char*)(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))) : null; + if (_len1913) deallocate ~= cast()_ptr1913; + auto _list1914 = WitString(_ptr1913[0.._len1913]); + wit.pumpkin.plugin.java_packets.common.CEntityVelocity _record1915 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + velocity: _list1914, + }; + auto _payload2616 = _record1915; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cEntityVelocity(_payload2616); + break; + } + case _Tag2551.cExplosion: { + auto _tuple1917 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 40)), + *(cast(double*)(arg0 + 48)), + *(cast(double*)(arg0 + 56)), + ); + Option!(Tuple!(double, double, double)) _option1921 = void; + bool _isSome1921 = (cast(uint)(*(cast(ubyte*)(arg0 + 72)))) != 0; + if (_isSome1921) { + auto _tuple1920 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 80)), + *(cast(double*)(arg0 + 88)), + *(cast(double*)(arg0 + 96)), + ); + + _option1921 = Option!(Tuple!(double, double, double)).makeSome(_tuple1920); + } else { + _option1921 = Option!(Tuple!(double, double, double)).makeNone; + } + auto _len1922 = *(cast(size_t*)(arg0 + (104+2*size_t.sizeof))); + auto _ptr1922 = _len1922 ? cast(char*)(*(cast(void**)(arg0 + (104+1*size_t.sizeof)))) : null; + if (_len1922) deallocate ~= cast()_ptr1922; + auto _list1923 = WitString(_ptr1922[0.._len1922]); + wit.pumpkin.plugin.java_packets.common.CExplosion _record1924 = { + center: _tuple1917, + radius: *(cast(float*)(arg0 + 64)), + blockCount: cast(int)(*(cast(uint*)(arg0 + 68))), + knockback: _option1921, + particle: cast(int)(*(cast(uint*)(arg0 + 104))), + sound: _list1923, + blockParticlesPoolSize: cast(int)(*(cast(uint*)(arg0 + (104+3*size_t.sizeof)))), + }; + auto _payload2617 = _record1924; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cExplosion(_payload2617); + break; + } + case _Tag2551.cGameEvent: { + wit.pumpkin.plugin.java_packets.common.CGameEvent _record1926 = { + event: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 40)))), + value: *(cast(float*)(arg0 + 44)), + }; + auto _payload2618 = _record1926; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cGameEvent(_payload2618); + break; + } + case _Tag2551.cGameRuleValues: { + auto _listSrcPtr1934 = *(cast(void**)(arg0 + 40)); + auto _listLen1934 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _list1934 = _listLen1934 ? wit.common.mallocSlice!(Tuple!(WitString, WitString))(_listLen1934) : []; + assert(!_listLen1934 || _list1934.ptr); + if (_listLen1934) deallocate ~= cast(void*)_list1934.ptr; + foreach (_elem1928_idx, ref _elem1928; _list1934) { + const auto _base1928 = _listSrcPtr1934 + _elem1928_idx * (4*size_t.sizeof); + auto _len1929 = *(cast(size_t*)(_base1928 + size_t.sizeof)); + auto _ptr1929 = _len1929 ? cast(char*)(*(cast(void**)(_base1928 + 0))) : null; + if (_len1929) deallocate ~= cast()_ptr1929; + auto _list1930 = WitString(_ptr1929[0.._len1929]); + auto _len1931 = *(cast(size_t*)(_base1928 + (3*size_t.sizeof))); + auto _ptr1931 = _len1931 ? cast(char*)(*(cast(void**)(_base1928 + (2*size_t.sizeof)))) : null; + if (_len1931) deallocate ~= cast()_ptr1931; + auto _list1932 = WitString(_ptr1931[0.._len1931]); + auto _tuple1933 = Tuple!(WitString, WitString)( + _list1930, + _list1932, + ); + _elem1928 = _tuple1933; + } + if (_listLen1934) deallocate ~= _listSrcPtr1934; + auto _witList1935 = WitList!(Tuple!(WitString, WitString))(_list1934); + wit.pumpkin.plugin.java_packets.common.CGameRuleValues _record1936 = { + rules: _witList1935, + }; + auto _payload2619 = _record1936; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cGameRuleValues(_payload2619); + break; + } + case _Tag2551.cGameTestHighlightPos: { + auto _tuple1938 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 40))), + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + ); + auto _len1939 = *(cast(size_t*)(arg0 + (56+1*size_t.sizeof))); + auto _ptr1939 = _len1939 ? cast(char*)(*(cast(void**)(arg0 + 56))) : null; + if (_len1939) deallocate ~= cast()_ptr1939; + auto _list1940 = WitString(_ptr1939[0.._len1939]); + wit.pumpkin.plugin.java_packets.common.CGameTestHighlightPos _record1941 = { + pos: _tuple1938, + color: cast(int)(*(cast(uint*)(arg0 + 52))), + label: _list1940, + durationMs: cast(int)(*(cast(uint*)(arg0 + (56+2*size_t.sizeof)))), + }; + auto _payload2620 = _record1941; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cGameTestHighlightPos(_payload2620); + break; + } + case _Tag2551.cHeadRot: { + wit.pumpkin.plugin.java_packets.common.CHeadRot _record1943 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + headYaw: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 44)))), + }; + auto _payload2621 = _record1943; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cHeadRot(_payload2621); + break; + } + case _Tag2551.cHurtAnimation: { + wit.pumpkin.plugin.java_packets.common.CHurtAnimation _record1945 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + yaw: *(cast(float*)(arg0 + 44)), + }; + auto _payload2622 = _record1945; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cHurtAnimation(_payload2622); + break; + } + case _Tag2551.cInitializeWorldBorder: { + wit.pumpkin.plugin.java_packets.common.CInitializeWorldBorder _record1947 = { + x: *(cast(double*)(arg0 + 40)), + z: *(cast(double*)(arg0 + 48)), + oldDiameter: *(cast(double*)(arg0 + 56)), + newDiameter: *(cast(double*)(arg0 + 64)), + speed: cast(long)(*(cast(ulong*)(arg0 + 72))), + portalTeleportBoundary: cast(int)(*(cast(uint*)(arg0 + 80))), + warningBlocks: cast(int)(*(cast(uint*)(arg0 + 84))), + warningTime: cast(int)(*(cast(uint*)(arg0 + 88))), + }; + auto _payload2623 = _record1947; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cInitializeWorldBorder(_payload2623); + break; + } + case _Tag2551.cItemCooldown: { + auto _len1949 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr1949 = _len1949 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len1949) deallocate ~= cast()_ptr1949; + auto _list1950 = WitString(_ptr1949[0.._len1949]); + wit.pumpkin.plugin.java_packets.common.CItemCooldown _record1951 = { + group: _list1950, + cooldown: cast(int)(*(cast(uint*)(arg0 + (40+2*size_t.sizeof)))), + }; + auto _payload2624 = _record1951; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cItemCooldown(_payload2624); + break; + } + case _Tag2551.cKeepAlive: { + wit.pumpkin.plugin.java_packets.common.CKeepAlive _record1953 = { + keepAliveId: cast(long)(*(cast(ulong*)(arg0 + 40))), + }; + auto _payload2625 = _record1953; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cKeepAlive(_payload2625); + break; + } + case _Tag2551.cLevelEvent: { + auto _tuple1955 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + cast(int)(*(cast(uint*)(arg0 + 52))), + ); + wit.pumpkin.plugin.java_packets.common.CLevelEvent _record1956 = { + event: cast(int)(*(cast(uint*)(arg0 + 40))), + location: _tuple1955, + data: cast(int)(*(cast(uint*)(arg0 + 56))), + disableRelativeVolume: (cast(uint)(*(cast(ubyte*)(arg0 + 60)))) != 0, + }; + auto _payload2626 = _record1956; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cLevelEvent(_payload2626); + break; + } + case _Tag2551.cLightUpdate: { + auto _len1958 = *(cast(size_t*)(arg0 + (48+2*size_t.sizeof))); + auto _ptr1958 = _len1958 ? cast(long*)(*(cast(void**)(arg0 + (48+1*size_t.sizeof)))) : null; + if (_len1958) deallocate ~= cast()_ptr1958; + auto _list1959 = WitList!(long)(_ptr1958[0.._len1958]); + auto _len1960 = *(cast(size_t*)(arg0 + (48+4*size_t.sizeof))); + auto _ptr1960 = _len1960 ? cast(long*)(*(cast(void**)(arg0 + (48+3*size_t.sizeof)))) : null; + if (_len1960) deallocate ~= cast()_ptr1960; + auto _list1961 = WitList!(long)(_ptr1960[0.._len1960]); + auto _len1962 = *(cast(size_t*)(arg0 + (48+6*size_t.sizeof))); + auto _ptr1962 = _len1962 ? cast(long*)(*(cast(void**)(arg0 + (48+5*size_t.sizeof)))) : null; + if (_len1962) deallocate ~= cast()_ptr1962; + auto _list1963 = WitList!(long)(_ptr1962[0.._len1962]); + auto _len1964 = *(cast(size_t*)(arg0 + (48+8*size_t.sizeof))); + auto _ptr1964 = _len1964 ? cast(long*)(*(cast(void**)(arg0 + (48+7*size_t.sizeof)))) : null; + if (_len1964) deallocate ~= cast()_ptr1964; + auto _list1965 = WitList!(long)(_ptr1964[0.._len1964]); + auto _listSrcPtr1969 = *(cast(void**)(arg0 + (48+9*size_t.sizeof))); + auto _listLen1969 = *(cast(size_t*)(arg0 + (48+10*size_t.sizeof))); + auto _list1969 = _listLen1969 ? wit.common.mallocSlice!(WitList!(ubyte))(_listLen1969) : []; + assert(!_listLen1969 || _list1969.ptr); + if (_listLen1969) deallocate ~= cast(void*)_list1969.ptr; + foreach (_elem1966_idx, ref _elem1966; _list1969) { + const auto _base1966 = _listSrcPtr1969 + _elem1966_idx * (2*size_t.sizeof); + auto _len1967 = *(cast(size_t*)(_base1966 + size_t.sizeof)); + auto _ptr1967 = _len1967 ? cast(ubyte*)(*(cast(void**)(_base1966 + 0))) : null; + if (_len1967) deallocate ~= cast()_ptr1967; + auto _list1968 = WitList!(ubyte)(_ptr1967[0.._len1967]); + _elem1966 = _list1968; + } + if (_listLen1969) deallocate ~= _listSrcPtr1969; + auto _witList1970 = WitList!(WitList!(ubyte))(_list1969); + auto _listSrcPtr1974 = *(cast(void**)(arg0 + (48+11*size_t.sizeof))); + auto _listLen1974 = *(cast(size_t*)(arg0 + (48+12*size_t.sizeof))); + auto _list1974 = _listLen1974 ? wit.common.mallocSlice!(WitList!(ubyte))(_listLen1974) : []; + assert(!_listLen1974 || _list1974.ptr); + if (_listLen1974) deallocate ~= cast(void*)_list1974.ptr; + foreach (_elem1971_idx, ref _elem1971; _list1974) { + const auto _base1971 = _listSrcPtr1974 + _elem1971_idx * (2*size_t.sizeof); + auto _len1972 = *(cast(size_t*)(_base1971 + size_t.sizeof)); + auto _ptr1972 = _len1972 ? cast(ubyte*)(*(cast(void**)(_base1971 + 0))) : null; + if (_len1972) deallocate ~= cast()_ptr1972; + auto _list1973 = WitList!(ubyte)(_ptr1972[0.._len1972]); + _elem1971 = _list1973; + } + if (_listLen1974) deallocate ~= _listSrcPtr1974; + auto _witList1975 = WitList!(WitList!(ubyte))(_list1974); + wit.pumpkin.plugin.java_packets.common.LightData _record1976 = { + trustEdges: (cast(uint)(*(cast(ubyte*)(arg0 + 48)))) != 0, + skyLightMask: _list1959, + blockLightMask: _list1961, + emptySkyLightMask: _list1963, + emptyBlockLightMask: _list1965, + skyLightArrays: _witList1970, + blockLightArrays: _witList1975, + }; + wit.pumpkin.plugin.java_packets.common.CLightUpdate _record1977 = { + chunkX: cast(int)(*(cast(uint*)(arg0 + 40))), + chunkZ: cast(int)(*(cast(uint*)(arg0 + 44))), + lightData: _record1976, + }; + auto _payload2627 = _record1977; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cLightUpdate(_payload2627); + break; + } + case _Tag2551.cLogin: { + auto _listSrcPtr1982 = *(cast(void**)(arg0 + 48)); + auto _listLen1982 = *(cast(size_t*)(arg0 + (48+1*size_t.sizeof))); + auto _list1982 = _listLen1982 ? wit.common.mallocSlice!(WitString)(_listLen1982) : []; + assert(!_listLen1982 || _list1982.ptr); + if (_listLen1982) deallocate ~= cast(void*)_list1982.ptr; + foreach (_elem1979_idx, ref _elem1979; _list1982) { + const auto _base1979 = _listSrcPtr1982 + _elem1979_idx * (2*size_t.sizeof); + auto _len1980 = *(cast(size_t*)(_base1979 + size_t.sizeof)); + auto _ptr1980 = _len1980 ? cast(char*)(*(cast(void**)(_base1979 + 0))) : null; + if (_len1980) deallocate ~= cast()_ptr1980; + auto _list1981 = WitString(_ptr1980[0.._len1980]); + _elem1979 = _list1981; + } + if (_listLen1982) deallocate ~= _listSrcPtr1982; + auto _witList1983 = WitList!(WitString)(_list1982); + auto _len1984 = *(cast(size_t*)(arg0 + (64+3*size_t.sizeof))); + auto _ptr1984 = _len1984 ? cast(char*)(*(cast(void**)(arg0 + (64+2*size_t.sizeof)))) : null; + if (_len1984) deallocate ~= cast()_ptr1984; + auto _list1985 = WitString(_ptr1984[0.._len1984]); + Option!(Tuple!(WitString, Tuple!(int, int, int))) _option1992 = void; + bool _isSome1992 = (cast(uint)(*(cast(ubyte*)(arg0 + (72+5*size_t.sizeof))))) != 0; + if (_isSome1992) { + auto _len1988 = *(cast(size_t*)(arg0 + (72+7*size_t.sizeof))); + auto _ptr1988 = _len1988 ? cast(char*)(*(cast(void**)(arg0 + (72+6*size_t.sizeof)))) : null; + if (_len1988) deallocate ~= cast()_ptr1988; + auto _list1989 = WitString(_ptr1988[0.._len1988]); + auto _tuple1990 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + (72+8*size_t.sizeof)))), + cast(int)(*(cast(uint*)(arg0 + (76+8*size_t.sizeof)))), + cast(int)(*(cast(uint*)(arg0 + (80+8*size_t.sizeof)))), + ); + auto _tuple1991 = Tuple!(WitString, Tuple!(int, int, int))( + _list1989, + _tuple1990, + ); + + _option1992 = Option!(Tuple!(WitString, Tuple!(int, int, int))).makeSome(_tuple1991); + } else { + _option1992 = Option!(Tuple!(WitString, Tuple!(int, int, int))).makeNone; + } + wit.pumpkin.plugin.java_packets.common.PlayerSpawnData _record1993 = { + dimension: _list1985, + hashedSeed: cast(long)(*(cast(ulong*)(arg0 + (64+4*size_t.sizeof)))), + gameMode: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (72+4*size_t.sizeof))))), + previousGamemode: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (73+4*size_t.sizeof))))), + debug_: (cast(uint)(*(cast(ubyte*)(arg0 + (74+4*size_t.sizeof))))) != 0, + isFlat: (cast(uint)(*(cast(ubyte*)(arg0 + (75+4*size_t.sizeof))))) != 0, + deathDimensionName: _option1992, + portalCooldown: cast(int)(*(cast(uint*)(arg0 + (80+9*size_t.sizeof)))), + sealevel: cast(int)(*(cast(uint*)(arg0 + (84+9*size_t.sizeof)))), + }; + wit.pumpkin.plugin.java_packets.common.CLogin _record1994 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + isHardcore: (cast(uint)(*(cast(ubyte*)(arg0 + 44)))) != 0, + dimensionNames: _witList1983, + maxPlayers: cast(int)(*(cast(uint*)(arg0 + (48+2*size_t.sizeof)))), + viewDistance: cast(int)(*(cast(uint*)(arg0 + (52+2*size_t.sizeof)))), + simulatedDistance: cast(int)(*(cast(uint*)(arg0 + (56+2*size_t.sizeof)))), + reducedDebugInfo: (cast(uint)(*(cast(ubyte*)(arg0 + (60+2*size_t.sizeof))))) != 0, + enabledRespawnScreen: (cast(uint)(*(cast(ubyte*)(arg0 + (61+2*size_t.sizeof))))) != 0, + limitedCrafting: (cast(uint)(*(cast(ubyte*)(arg0 + (62+2*size_t.sizeof))))) != 0, + spawnData: _record1993, + onlineMode: (cast(uint)(*(cast(ubyte*)(arg0 + (96+8*size_t.sizeof))))) != 0, + enforceSecureChat: (cast(uint)(*(cast(ubyte*)(arg0 + (97+8*size_t.sizeof))))) != 0, + }; + auto _payload2628 = _record1994; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cLogin(_payload2628); + break; + } + case _Tag2551.cLowDiskSpaceWarning: { + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cLowDiskSpaceWarning(); + break; + } + case _Tag2551.cMapItemData: { + Option!(WitList!(wit.pumpkin.plugin.java_packets.common.MapIcon)) _option2008 = void; + bool _isSome2008 = (cast(uint)(*(cast(ubyte*)(arg0 + 48)))) != 0; + if (_isSome2008) { + auto _listSrcPtr2006 = *(cast(void**)(arg0 + (48+1*size_t.sizeof))); + auto _listLen2006 = *(cast(size_t*)(arg0 + (48+2*size_t.sizeof))); + auto _list2006 = _listLen2006 ? wit.common.mallocSlice!(wit.pumpkin.plugin.java_packets.common.MapIcon)(_listLen2006) : []; + assert(!_listLen2006 || _list2006.ptr); + if (_listLen2006) deallocate ~= cast(void*)_list2006.ptr; + foreach (_elem1999_idx, ref _elem1999; _list2006) { + const auto _base1999 = _listSrcPtr2006 + _elem1999_idx * (8+3*size_t.sizeof); + Option!(WitString) _option2004 = void; + bool _isSome2004 = (cast(uint)(*(cast(ubyte*)(_base1999 + 8)))) != 0; + if (_isSome2004) { + auto _len2002 = *(cast(size_t*)(_base1999 + (8+2*size_t.sizeof))); + auto _ptr2002 = _len2002 ? cast(char*)(*(cast(void**)(_base1999 + (8+1*size_t.sizeof)))) : null; + if (_len2002) deallocate ~= cast()_ptr2002; + auto _list2003 = WitString(_ptr2002[0.._len2002]); + + _option2004 = Option!(WitString).makeSome(_list2003); + } else { + _option2004 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.java_packets.common.MapIcon _record2005 = { + iconType: cast(int)(*(cast(uint*)(_base1999 + 0))), + x: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1999 + 4)))), + z: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1999 + 5)))), + direction: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base1999 + 6)))), + displayName: _option2004, + }; + _elem1999 = _record2005; + } + if (_listLen2006) deallocate ~= _listSrcPtr2006; + auto _witList2007 = WitList!(wit.pumpkin.plugin.java_packets.common.MapIcon)(_list2006); + + _option2008 = Option!(WitList!(wit.pumpkin.plugin.java_packets.common.MapIcon)).makeSome(_witList2007); + } else { + _option2008 = Option!(WitList!(wit.pumpkin.plugin.java_packets.common.MapIcon)).makeNone; + } + Option!(wit.pumpkin.plugin.java_packets.common.MapPatch) _option2014 = void; + bool _isSome2014 = (cast(uint)(*(cast(ubyte*)(arg0 + (48+3*size_t.sizeof))))) != 0; + if (_isSome2014) { + auto _len2011 = *(cast(size_t*)(arg0 + (48+6*size_t.sizeof))); + auto _ptr2011 = _len2011 ? cast(ubyte*)(*(cast(void**)(arg0 + (48+5*size_t.sizeof)))) : null; + if (_len2011) deallocate ~= cast()_ptr2011; + auto _list2012 = WitList!(ubyte)(_ptr2011[0.._len2011]); + wit.pumpkin.plugin.java_packets.common.MapPatch _record2013 = { + columns: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (48+4*size_t.sizeof))))), + rows: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (49+4*size_t.sizeof))))), + x: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (50+4*size_t.sizeof))))), + z: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (51+4*size_t.sizeof))))), + data: _list2012, + }; + + _option2014 = Option!(wit.pumpkin.plugin.java_packets.common.MapPatch).makeSome(_record2013); + } else { + _option2014 = Option!(wit.pumpkin.plugin.java_packets.common.MapPatch).makeNone; + } + wit.pumpkin.plugin.java_packets.common.CMapItemData _record2015 = { + mapId: cast(int)(*(cast(uint*)(arg0 + 40))), + scale: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 44)))), + trackingPosition: (cast(uint)(*(cast(ubyte*)(arg0 + 45)))) != 0, + locked: (cast(uint)(*(cast(ubyte*)(arg0 + 46)))) != 0, + icons: _option2008, + data: _option2014, + }; + auto _payload2630 = _record2015; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cMapItemData(_payload2630); + break; + } + case _Tag2551.cMerchantOffers: { + auto _listSrcPtr2028 = *(cast(void**)(arg0 + (40+1*size_t.sizeof))); + auto _listLen2028 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _list2028 = _listLen2028 ? wit.common.mallocSlice!(wit.pumpkin.plugin.java_packets.common.MerchantOffer)(_listLen2028) : []; + assert(!_listLen2028 || _list2028.ptr); + if (_listLen2028) deallocate ~= cast(void*)_list2028.ptr; + foreach (_elem2017_idx, ref _elem2017; _list2028) { + const auto _base2017 = _listSrcPtr2028 + _elem2017_idx * (24+8*size_t.sizeof); + auto _len2018 = *(cast(size_t*)(_base2017 + size_t.sizeof)); + auto _ptr2018 = _len2018 ? cast(char*)(*(cast(void**)(_base2017 + 0))) : null; + if (_len2018) deallocate ~= cast()_ptr2018; + auto _list2019 = WitString(_ptr2018[0.._len2018]); + auto _len2020 = *(cast(size_t*)(_base2017 + (3*size_t.sizeof))); + auto _ptr2020 = _len2020 ? cast(char*)(*(cast(void**)(_base2017 + (2*size_t.sizeof)))) : null; + if (_len2020) deallocate ~= cast()_ptr2020; + auto _list2021 = WitString(_ptr2020[0.._len2020]); + Option!(WitString) _option2026 = void; + bool _isSome2026 = (cast(uint)(*(cast(ubyte*)(_base2017 + (4*size_t.sizeof))))) != 0; + if (_isSome2026) { + auto _len2024 = *(cast(size_t*)(_base2017 + (6*size_t.sizeof))); + auto _ptr2024 = _len2024 ? cast(char*)(*(cast(void**)(_base2017 + (5*size_t.sizeof)))) : null; + if (_len2024) deallocate ~= cast()_ptr2024; + auto _list2025 = WitString(_ptr2024[0.._len2024]); + + _option2026 = Option!(WitString).makeSome(_list2025); + } else { + _option2026 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.java_packets.common.MerchantOffer _record2027 = { + baseCostA: _list2019, + output: _list2021, + costB: _option2026, + rewardExp: (cast(uint)(*(cast(ubyte*)(_base2017 + (7*size_t.sizeof))))) != 0, + uses: cast(int)(*(cast(uint*)(_base2017 + (4+7*size_t.sizeof)))), + maxUses: cast(int)(*(cast(uint*)(_base2017 + (8+7*size_t.sizeof)))), + xp: cast(int)(*(cast(uint*)(_base2017 + (12+7*size_t.sizeof)))), + specialPrice: cast(int)(*(cast(uint*)(_base2017 + (16+7*size_t.sizeof)))), + priceMultiplier: *(cast(float*)(_base2017 + (20+7*size_t.sizeof))), + demand: cast(int)(*(cast(uint*)(_base2017 + (24+7*size_t.sizeof)))), + }; + _elem2017 = _record2027; + } + if (_listLen2028) deallocate ~= _listSrcPtr2028; + auto _witList2029 = WitList!(wit.pumpkin.plugin.java_packets.common.MerchantOffer)(_list2028); + wit.pumpkin.plugin.java_packets.common.CMerchantOffers _record2030 = { + windowId: cast(int)(*(cast(uint*)(arg0 + 40))), + offers: _witList2029, + villagerLevel: cast(int)(*(cast(uint*)(arg0 + (40+3*size_t.sizeof)))), + experience: cast(int)(*(cast(uint*)(arg0 + (44+3*size_t.sizeof)))), + isRegularVillager: (cast(uint)(*(cast(ubyte*)(arg0 + (48+3*size_t.sizeof))))) != 0, + canRestock: (cast(uint)(*(cast(ubyte*)(arg0 + (49+3*size_t.sizeof))))) != 0, + }; + auto _payload2631 = _record2030; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cMerchantOffers(_payload2631); + break; + } + case _Tag2551.cMoveMinecartAlongTrack: { + auto _len2032 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _ptr2032 = _len2032 ? cast(wit.pumpkin.plugin.java_packets.common.MinecartStep*)(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))) : null; + if (_len2032) deallocate ~= cast()_ptr2032; + auto _list2033 = WitList!(wit.pumpkin.plugin.java_packets.common.MinecartStep)(_ptr2032[0.._len2032]); + wit.pumpkin.plugin.java_packets.common.CMoveMinecartAlongTrack _record2034 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + steps: _list2033, + }; + auto _payload2632 = _record2034; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cMoveMinecartAlongTrack(_payload2632); + break; + } + case _Tag2551.cMoveVehicle: { + wit.pumpkin.plugin.java_packets.common.CMoveVehicle _record2036 = { + x: *(cast(double*)(arg0 + 40)), + y: *(cast(double*)(arg0 + 48)), + z: *(cast(double*)(arg0 + 56)), + yaw: *(cast(float*)(arg0 + 64)), + pitch: *(cast(float*)(arg0 + 68)), + }; + auto _payload2633 = _record2036; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cMoveVehicle(_payload2633); + break; + } + case _Tag2551.cMultiBlockUpdate: { + auto _tuple2038 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 40)), + *(cast(double*)(arg0 + 48)), + *(cast(double*)(arg0 + 56)), + ); + auto _listSrcPtr2044 = *(cast(void**)(arg0 + (64+1*size_t.sizeof))); + auto _listLen2044 = *(cast(size_t*)(arg0 + (64+2*size_t.sizeof))); + auto _list2044 = _listLen2044 ? wit.common.mallocSlice!(Tuple!(Tuple!(int, int, int), WitString))(_listLen2044) : []; + assert(!_listLen2044 || _list2044.ptr); + if (_listLen2044) deallocate ~= cast(void*)_list2044.ptr; + foreach (_elem2039_idx, ref _elem2039; _list2044) { + const auto _base2039 = _listSrcPtr2044 + _elem2039_idx * (8+3*size_t.sizeof); + auto _tuple2040 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(_base2039 + 0))), + cast(int)(*(cast(uint*)(_base2039 + 4))), + cast(int)(*(cast(uint*)(_base2039 + 8))), + ); + auto _len2041 = *(cast(size_t*)(_base2039 + (8+2*size_t.sizeof))); + auto _ptr2041 = _len2041 ? cast(char*)(*(cast(void**)(_base2039 + (8+1*size_t.sizeof)))) : null; + if (_len2041) deallocate ~= cast()_ptr2041; + auto _list2042 = WitString(_ptr2041[0.._len2041]); + auto _tuple2043 = Tuple!(Tuple!(int, int, int), WitString)( + _tuple2040, + _list2042, + ); + _elem2039 = _tuple2043; + } + if (_listLen2044) deallocate ~= _listSrcPtr2044; + auto _witList2045 = WitList!(Tuple!(Tuple!(int, int, int), WitString))(_list2044); + wit.pumpkin.plugin.java_packets.common.CMultiBlockUpdate _record2046 = { + chunkSection: _tuple2038, + suppressLightUpdates: (cast(uint)(*(cast(ubyte*)(arg0 + 64)))) != 0, + updates: _witList2045, + }; + auto _payload2634 = _record2046; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cMultiBlockUpdate(_payload2634); + break; + } + case _Tag2551.cOpenBook: { + wit.pumpkin.plugin.java_packets.common.COpenBook _record2048 = { + hand: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload2635 = _record2048; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cOpenBook(_payload2635); + break; + } + case _Tag2551.cOpenMountScreen: { + wit.pumpkin.plugin.java_packets.common.COpenMountScreen _record2050 = { + windowId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 40)))), + slotCount: cast(int)(*(cast(uint*)(arg0 + 44))), + entityId: cast(int)(*(cast(uint*)(arg0 + 48))), + }; + auto _payload2636 = _record2050; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cOpenMountScreen(_payload2636); + break; + } + case _Tag2551.cOpenScreen: { + auto _len2052 = *(cast(size_t*)(arg0 + (48+1*size_t.sizeof))); + auto _ptr2052 = _len2052 ? cast(char*)(*(cast(void**)(arg0 + 48))) : null; + if (_len2052) deallocate ~= cast()_ptr2052; + auto _list2053 = WitString(_ptr2052[0.._len2052]); + wit.pumpkin.plugin.java_packets.common.COpenScreen _record2054 = { + syncId: cast(int)(*(cast(uint*)(arg0 + 40))), + windowType: cast(int)(*(cast(uint*)(arg0 + 44))), + windowTitle: _list2053, + }; + auto _payload2637 = _record2054; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cOpenScreen(_payload2637); + break; + } + case _Tag2551.cOpenSignEditor: { + auto _tuple2056 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 40))), + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + ); + wit.pumpkin.plugin.java_packets.common.COpenSignEditor _record2057 = { + location: _tuple2056, + isFrontText: (cast(uint)(*(cast(ubyte*)(arg0 + 52)))) != 0, + }; + auto _payload2638 = _record2057; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cOpenSignEditor(_payload2638); + break; + } + case _Tag2551.cParticle: { + auto _tuple2059 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 48)), + *(cast(double*)(arg0 + 56)), + *(cast(double*)(arg0 + 64)), + ); + auto _tuple2060 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 72)), + *(cast(double*)(arg0 + 80)), + *(cast(double*)(arg0 + 88)), + ); + auto _len2061 = *(cast(size_t*)(arg0 + (104+2*size_t.sizeof))); + auto _ptr2061 = _len2061 ? cast(ubyte*)(*(cast(void**)(arg0 + (104+1*size_t.sizeof)))) : null; + if (_len2061) deallocate ~= cast()_ptr2061; + auto _list2062 = WitList!(ubyte)(_ptr2061[0.._len2061]); + wit.pumpkin.plugin.java_packets.common.CParticle _record2063 = { + forceSpawn: (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0, + important: (cast(uint)(*(cast(ubyte*)(arg0 + 41)))) != 0, + position: _tuple2059, + offset: _tuple2060, + maxSpeed: *(cast(float*)(arg0 + 96)), + particleCount: cast(int)(*(cast(uint*)(arg0 + 100))), + particleId: cast(int)(*(cast(uint*)(arg0 + 104))), + data: _list2062, + }; + auto _payload2639 = _record2063; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cParticle(_payload2639); + break; + } + case _Tag2551.cPlayPing: { + wit.pumpkin.plugin.java_packets.common.CPlayPing _record2065 = { + id: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload2640 = _record2065; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cPlayPing(_payload2640); + break; + } + case _Tag2551.cPingResponse: { + wit.pumpkin.plugin.java_packets.common.CPingResponse _record2067 = { + payload: cast(long)(*(cast(ulong*)(arg0 + 40))), + }; + auto _payload2641 = _record2067; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cPingResponse(_payload2641); + break; + } + case _Tag2551.cPlaceGhostRecipe: { + auto _len2069 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _ptr2069 = _len2069 ? cast(char*)(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))) : null; + if (_len2069) deallocate ~= cast()_ptr2069; + auto _list2070 = WitString(_ptr2069[0.._len2069]); + wit.pumpkin.plugin.java_packets.common.CPlaceGhostRecipe _record2071 = { + windowId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 40)))), + recipeId: _list2070, + }; + auto _payload2642 = _record2071; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cPlaceGhostRecipe(_payload2642); + break; + } + case _Tag2551.cPlayerAbilities: { + wit.pumpkin.plugin.java_packets.common.CPlayerAbilities _record2073 = { + flags: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 40)))), + flyingSpeed: *(cast(float*)(arg0 + 44)), + fieldOfView: *(cast(float*)(arg0 + 48)), + }; + auto _payload2643 = _record2073; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cPlayerAbilities(_payload2643); + break; + } + case _Tag2551.cPlayerChatMessage: { + wit.pumpkin.plugin.uuid.common.Uuid _record2075 = { + high: *(cast(ulong*)(arg0 + 48)), + low: *(cast(ulong*)(arg0 + 56)), + }; + Option!(WitList!(ubyte)) _option2080 = void; + bool _isSome2080 = (cast(uint)(*(cast(ubyte*)(arg0 + (64+1*size_t.sizeof))))) != 0; + if (_isSome2080) { + auto _len2078 = *(cast(size_t*)(arg0 + (64+3*size_t.sizeof))); + auto _ptr2078 = _len2078 ? cast(ubyte*)(*(cast(void**)(arg0 + (64+2*size_t.sizeof)))) : null; + if (_len2078) deallocate ~= cast()_ptr2078; + auto _list2079 = WitList!(ubyte)(_ptr2078[0.._len2078]); + + _option2080 = Option!(WitList!(ubyte)).makeSome(_list2079); + } else { + _option2080 = Option!(WitList!(ubyte)).makeNone; + } + auto _len2081 = *(cast(size_t*)(arg0 + (64+5*size_t.sizeof))); + auto _ptr2081 = _len2081 ? cast(char*)(*(cast(void**)(arg0 + (64+4*size_t.sizeof)))) : null; + if (_len2081) deallocate ~= cast()_ptr2081; + auto _list2082 = WitString(_ptr2081[0.._len2081]); + auto _listSrcPtr2090 = *(cast(void**)(arg0 + (80+6*size_t.sizeof))); + auto _listLen2090 = *(cast(size_t*)(arg0 + (80+7*size_t.sizeof))); + auto _list2090 = _listLen2090 ? wit.common.mallocSlice!(wit.pumpkin.plugin.java_packets.common.PreviousMessage)(_listLen2090) : []; + assert(!_listLen2090 || _list2090.ptr); + if (_listLen2090) deallocate ~= cast(void*)_list2090.ptr; + foreach (_elem2083_idx, ref _elem2083; _list2090) { + const auto _base2083 = _listSrcPtr2090 + _elem2083_idx * (4*size_t.sizeof); + Option!(WitList!(ubyte)) _option2088 = void; + bool _isSome2088 = (cast(uint)(*(cast(ubyte*)(_base2083 + size_t.sizeof)))) != 0; + if (_isSome2088) { + auto _len2086 = *(cast(size_t*)(_base2083 + (3*size_t.sizeof))); + auto _ptr2086 = _len2086 ? cast(ubyte*)(*(cast(void**)(_base2083 + (2*size_t.sizeof)))) : null; + if (_len2086) deallocate ~= cast()_ptr2086; + auto _list2087 = WitList!(ubyte)(_ptr2086[0.._len2086]); + + _option2088 = Option!(WitList!(ubyte)).makeSome(_list2087); + } else { + _option2088 = Option!(WitList!(ubyte)).makeNone; + } + wit.pumpkin.plugin.java_packets.common.PreviousMessage _record2089 = { + id: cast(int)(*(cast(uint*)(_base2083 + 0))), + signature: _option2088, + }; + _elem2083 = _record2089; + } + if (_listLen2090) deallocate ~= _listSrcPtr2090; + auto _witList2091 = WitList!(wit.pumpkin.plugin.java_packets.common.PreviousMessage)(_list2090); + Option!(WitString) _option2096 = void; + bool _isSome2096 = (cast(uint)(*(cast(ubyte*)(arg0 + (80+8*size_t.sizeof))))) != 0; + if (_isSome2096) { + auto _len2094 = *(cast(size_t*)(arg0 + (80+10*size_t.sizeof))); + auto _ptr2094 = _len2094 ? cast(char*)(*(cast(void**)(arg0 + (80+9*size_t.sizeof)))) : null; + if (_len2094) deallocate ~= cast()_ptr2094; + auto _list2095 = WitString(_ptr2094[0.._len2094]); + + _option2096 = Option!(WitString).makeSome(_list2095); + } else { + _option2096 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.java_packets.common.FilterType _variant2102 = void; + auto _tag2102 = cast(uint)(*(cast(ubyte*)(arg0 + (80+11*size_t.sizeof)))); + alias _Tag2102 = wit.pumpkin.plugin.java_packets.common.FilterType.Tag; + final switch (cast(wit.pumpkin.plugin.java_packets.common.FilterType.Tag)_tag2102) { + case _Tag2102.passThrough: { + _variant2102 = wit.pumpkin.plugin.java_packets.common.FilterType.passThrough(); + break; + } + case _Tag2102.fullyFiltered: { + _variant2102 = wit.pumpkin.plugin.java_packets.common.FilterType.fullyFiltered(); + break; + } + case _Tag2102.partiallyFiltered: { + auto _len2100 = *(cast(size_t*)(arg0 + (80+13*size_t.sizeof))); + auto _ptr2100 = _len2100 ? cast(long*)(*(cast(void**)(arg0 + (80+12*size_t.sizeof)))) : null; + if (_len2100) deallocate ~= cast()_ptr2100; + auto _list2101 = WitList!(long)(_ptr2100[0.._len2100]); + auto _payload2105 = _list2101; + _variant2102 = wit.pumpkin.plugin.java_packets.common.FilterType.partiallyFiltered(_payload2105); + break; + } + } + auto _len2106 = *(cast(size_t*)(arg0 + (80+16*size_t.sizeof))); + auto _ptr2106 = _len2106 ? cast(char*)(*(cast(void**)(arg0 + (80+15*size_t.sizeof)))) : null; + if (_len2106) deallocate ~= cast()_ptr2106; + auto _list2107 = WitString(_ptr2106[0.._len2106]); + Option!(WitString) _option2112 = void; + bool _isSome2112 = (cast(uint)(*(cast(ubyte*)(arg0 + (80+17*size_t.sizeof))))) != 0; + if (_isSome2112) { + auto _len2110 = *(cast(size_t*)(arg0 + (80+19*size_t.sizeof))); + auto _ptr2110 = _len2110 ? cast(char*)(*(cast(void**)(arg0 + (80+18*size_t.sizeof)))) : null; + if (_len2110) deallocate ~= cast()_ptr2110; + auto _list2111 = WitString(_ptr2110[0.._len2110]); + + _option2112 = Option!(WitString).makeSome(_list2111); + } else { + _option2112 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.java_packets.common.CPlayerChatMessage _record2113 = { + globalIndex: cast(int)(*(cast(uint*)(arg0 + 40))), + sender: _record2075, + index: cast(int)(*(cast(uint*)(arg0 + 64))), + messageSignature: _option2080, + message: _list2082, + timestamp: cast(long)(*(cast(ulong*)(arg0 + (64+6*size_t.sizeof)))), + salt: cast(long)(*(cast(ulong*)(arg0 + (72+6*size_t.sizeof)))), + previousMessages: _witList2091, + unsignedContent: _option2096, + filterType: _variant2102, + chatType: cast(int)(*(cast(uint*)(arg0 + (80+14*size_t.sizeof)))), + senderName: _list2107, + targetName: _option2112, + }; + auto _payload2644 = _record2113; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cPlayerChatMessage(_payload2644); + break; + } + case _Tag2551.cPlayerInfoUpdate: { + auto _listSrcPtr2165 = *(cast(void**)(arg0 + (40+1*size_t.sizeof))); + auto _listLen2165 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _list2165 = _listLen2165 ? wit.common.mallocSlice!(wit.pumpkin.plugin.java_packets.common.Player)(_listLen2165) : []; + assert(!_listLen2165 || _list2165.ptr); + if (_listLen2165) deallocate ~= cast(void*)_list2165.ptr; + foreach (_elem2115_idx, ref _elem2115; _list2165) { + const auto _base2115 = _listSrcPtr2165 + _elem2115_idx * (16+2*size_t.sizeof); + wit.pumpkin.plugin.uuid.common.Uuid _record2116 = { + high: *(cast(ulong*)(_base2115 + 0)), + low: *(cast(ulong*)(_base2115 + 8)), + }; + auto _listSrcPtr2162 = *(cast(void**)(_base2115 + 16)); + auto _listLen2162 = *(cast(size_t*)(_base2115 + (16+1*size_t.sizeof))); + auto _list2162 = _listLen2162 ? wit.common.mallocSlice!(wit.pumpkin.plugin.java_packets.common.PlayerAction)(_listLen2162) : []; + assert(!_listLen2162 || _list2162.ptr); + if (_listLen2162) deallocate ~= cast(void*)_list2162.ptr; + foreach (_elem2117_idx, ref _elem2117; _list2162) { + const auto _base2117 = _listSrcPtr2162 + _elem2117_idx * (40+4*size_t.sizeof); + wit.pumpkin.plugin.java_packets.common.PlayerAction _variant2153 = void; + auto _tag2153 = cast(uint)(*(cast(ubyte*)(_base2117 + 0))); + alias _Tag2153 = wit.pumpkin.plugin.java_packets.common.PlayerAction.Tag; + final switch (cast(wit.pumpkin.plugin.java_packets.common.PlayerAction.Tag)_tag2153) { + case _Tag2153.addPlayer: { + auto _len2119 = *(cast(size_t*)(_base2117 + (8+1*size_t.sizeof))); + auto _ptr2119 = _len2119 ? cast(char*)(*(cast(void**)(_base2117 + 8))) : null; + if (_len2119) deallocate ~= cast()_ptr2119; + auto _list2120 = WitString(_ptr2119[0.._len2119]); + auto _listSrcPtr2129 = *(cast(void**)(_base2117 + (8+2*size_t.sizeof))); + auto _listLen2129 = *(cast(size_t*)(_base2117 + (8+3*size_t.sizeof))); + auto _list2129 = _listLen2129 ? wit.common.mallocSlice!(wit.pumpkin.plugin.java_packets.common.Property)(_listLen2129) : []; + assert(!_listLen2129 || _list2129.ptr); + if (_listLen2129) deallocate ~= cast(void*)_list2129.ptr; + foreach (_elem2121_idx, ref _elem2121; _list2129) { + const auto _base2121 = _listSrcPtr2129 + _elem2121_idx * (16+2*size_t.sizeof); + auto _listSrcPtr2126 = *(cast(void**)(_base2121 + 16)); + auto _listLen2126 = *(cast(size_t*)(_base2121 + (16+1*size_t.sizeof))); + auto _list2126 = _listLen2126 ? wit.common.mallocSlice!(wit.pumpkin.plugin.java_packets.common.AttributeModifier)(_listLen2126) : []; + assert(!_listLen2126 || _list2126.ptr); + if (_listLen2126) deallocate ~= cast(void*)_list2126.ptr; + foreach (_elem2122_idx, ref _elem2122; _list2126) { + const auto _base2122 = _listSrcPtr2126 + _elem2122_idx * (16+2*size_t.sizeof); + auto _len2123 = *(cast(size_t*)(_base2122 + size_t.sizeof)); + auto _ptr2123 = _len2123 ? cast(char*)(*(cast(void**)(_base2122 + 0))) : null; + if (_len2123) deallocate ~= cast()_ptr2123; + auto _list2124 = WitString(_ptr2123[0.._len2123]); + wit.pumpkin.plugin.java_packets.common.AttributeModifier _record2125 = { + id: _list2124, + amount: *(cast(double*)(_base2122 + (2*size_t.sizeof))), + operation: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base2122 + (8+2*size_t.sizeof))))), + }; + _elem2122 = _record2125; + } + if (_listLen2126) deallocate ~= _listSrcPtr2126; + auto _witList2127 = WitList!(wit.pumpkin.plugin.java_packets.common.AttributeModifier)(_list2126); + wit.pumpkin.plugin.java_packets.common.Property _record2128 = { + id: cast(int)(*(cast(uint*)(_base2121 + 0))), + value: *(cast(double*)(_base2121 + 8)), + modifiers: _witList2127, + }; + _elem2121 = _record2128; + } + if (_listLen2129) deallocate ~= _listSrcPtr2129; + auto _witList2130 = WitList!(wit.pumpkin.plugin.java_packets.common.Property)(_list2129); + wit.pumpkin.plugin.java_packets.common.PlayerActionAddPlayer _record2131 = { + name: _list2120, + properties: _witList2130, + }; + auto _payload2154 = _record2131; + _variant2153 = wit.pumpkin.plugin.java_packets.common.PlayerAction.addPlayer(_payload2154); + break; + } + case _Tag2153.initializeChat: { + Option!(wit.pumpkin.plugin.java_packets.common.InitChat) _option2141 = void; + bool _isSome2141 = (cast(uint)(*(cast(ubyte*)(_base2117 + 8)))) != 0; + if (_isSome2141) { + wit.pumpkin.plugin.uuid.common.Uuid _record2135 = { + high: *(cast(ulong*)(_base2117 + 16)), + low: *(cast(ulong*)(_base2117 + 24)), + }; + auto _len2136 = *(cast(size_t*)(_base2117 + (40+1*size_t.sizeof))); + auto _ptr2136 = _len2136 ? cast(ubyte*)(*(cast(void**)(_base2117 + 40))) : null; + if (_len2136) deallocate ~= cast()_ptr2136; + auto _list2137 = WitList!(ubyte)(_ptr2136[0.._len2136]); + auto _len2138 = *(cast(size_t*)(_base2117 + (40+3*size_t.sizeof))); + auto _ptr2138 = _len2138 ? cast(ubyte*)(*(cast(void**)(_base2117 + (40+2*size_t.sizeof)))) : null; + if (_len2138) deallocate ~= cast()_ptr2138; + auto _list2139 = WitList!(ubyte)(_ptr2138[0.._len2138]); + wit.pumpkin.plugin.java_packets.common.InitChat _record2140 = { + sessionId: _record2135, + expiresAt: cast(long)(*(cast(ulong*)(_base2117 + 32))), + publicKey: _list2137, + signature: _list2139, + }; + + _option2141 = Option!(wit.pumpkin.plugin.java_packets.common.InitChat).makeSome(_record2140); + } else { + _option2141 = Option!(wit.pumpkin.plugin.java_packets.common.InitChat).makeNone; + } + auto _payload2155 = _option2141; + _variant2153 = wit.pumpkin.plugin.java_packets.common.PlayerAction.initializeChat(_payload2155); + break; + } + case _Tag2153.updateGameMode: { + auto _payload2156 = cast(int)(*(cast(uint*)(_base2117 + 8))); + _variant2153 = wit.pumpkin.plugin.java_packets.common.PlayerAction.updateGameMode(_payload2156); + break; + } + case _Tag2153.updateListed: { + auto _payload2157 = (cast(uint)(*(cast(ubyte*)(_base2117 + 8)))) != 0; + _variant2153 = wit.pumpkin.plugin.java_packets.common.PlayerAction.updateListed(_payload2157); + break; + } + case _Tag2153.updateLatency: { + auto _payload2158 = cast(int)(*(cast(uint*)(_base2117 + 8))); + _variant2153 = wit.pumpkin.plugin.java_packets.common.PlayerAction.updateLatency(_payload2158); + break; + } + case _Tag2153.updateDisplayName: { + Option!(WitString) _option2150 = void; + bool _isSome2150 = (cast(uint)(*(cast(ubyte*)(_base2117 + 8)))) != 0; + if (_isSome2150) { + auto _len2148 = *(cast(size_t*)(_base2117 + (8+2*size_t.sizeof))); + auto _ptr2148 = _len2148 ? cast(char*)(*(cast(void**)(_base2117 + (8+1*size_t.sizeof)))) : null; + if (_len2148) deallocate ~= cast()_ptr2148; + auto _list2149 = WitString(_ptr2148[0.._len2148]); + + _option2150 = Option!(WitString).makeSome(_list2149); + } else { + _option2150 = Option!(WitString).makeNone; + } + auto _payload2159 = _option2150; + _variant2153 = wit.pumpkin.plugin.java_packets.common.PlayerAction.updateDisplayName(_payload2159); + break; + } + case _Tag2153.updateListOrder: { + auto _payload2160 = cast(int)(*(cast(uint*)(_base2117 + 8))); + _variant2153 = wit.pumpkin.plugin.java_packets.common.PlayerAction.updateListOrder(_payload2160); + break; + } + case _Tag2153.updateHat: { + auto _payload2161 = (cast(uint)(*(cast(ubyte*)(_base2117 + 8)))) != 0; + _variant2153 = wit.pumpkin.plugin.java_packets.common.PlayerAction.updateHat(_payload2161); + break; + } + } + _elem2117 = _variant2153; + } + if (_listLen2162) deallocate ~= _listSrcPtr2162; + auto _witList2163 = WitList!(wit.pumpkin.plugin.java_packets.common.PlayerAction)(_list2162); + wit.pumpkin.plugin.java_packets.common.Player _record2164 = { + uuid: _record2116, + actions: _witList2163, + }; + _elem2115 = _record2164; + } + if (_listLen2165) deallocate ~= _listSrcPtr2165; + auto _witList2166 = WitList!(wit.pumpkin.plugin.java_packets.common.Player)(_list2165); + wit.pumpkin.plugin.java_packets.common.CPlayerInfoUpdate _record2167 = { + actions: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 40)))), + players: _witList2166, + }; + auto _payload2645 = _record2167; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cPlayerInfoUpdate(_payload2645); + break; + } + case _Tag2551.cPlayerLookAt: { + Option!(Tuple!(int, int)) _option2172 = void; + bool _isSome2172 = (cast(uint)(*(cast(ubyte*)(arg0 + 72)))) != 0; + if (_isSome2172) { + auto _tuple2171 = Tuple!(int, int)( + cast(int)(*(cast(uint*)(arg0 + 76))), + cast(int)(*(cast(uint*)(arg0 + 80))), + ); + + _option2172 = Option!(Tuple!(int, int)).makeSome(_tuple2171); + } else { + _option2172 = Option!(Tuple!(int, int)).makeNone; + } + wit.pumpkin.plugin.java_packets.common.CPlayerLookAt _record2173 = { + fromAnchor: cast(int)(*(cast(uint*)(arg0 + 40))), + targetX: *(cast(double*)(arg0 + 48)), + targetY: *(cast(double*)(arg0 + 56)), + targetZ: *(cast(double*)(arg0 + 64)), + entity: _option2172, + }; + auto _payload2646 = _record2173; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cPlayerLookAt(_payload2646); + break; + } + case _Tag2551.cPlayerPosition: { + auto _tuple2175 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 48)), + *(cast(double*)(arg0 + 56)), + *(cast(double*)(arg0 + 64)), + ); + auto _tuple2176 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 72)), + *(cast(double*)(arg0 + 80)), + *(cast(double*)(arg0 + 88)), + ); + auto _listSrcPtr2180 = *(cast(void**)(arg0 + 104)); + auto _listLen2180 = *(cast(size_t*)(arg0 + (104+1*size_t.sizeof))); + auto _list2180 = _listLen2180 ? wit.common.mallocSlice!(WitString)(_listLen2180) : []; + assert(!_listLen2180 || _list2180.ptr); + if (_listLen2180) deallocate ~= cast(void*)_list2180.ptr; + foreach (_elem2177_idx, ref _elem2177; _list2180) { + const auto _base2177 = _listSrcPtr2180 + _elem2177_idx * (2*size_t.sizeof); + auto _len2178 = *(cast(size_t*)(_base2177 + size_t.sizeof)); + auto _ptr2178 = _len2178 ? cast(char*)(*(cast(void**)(_base2177 + 0))) : null; + if (_len2178) deallocate ~= cast()_ptr2178; + auto _list2179 = WitString(_ptr2178[0.._len2178]); + _elem2177 = _list2179; + } + if (_listLen2180) deallocate ~= _listSrcPtr2180; + auto _witList2181 = WitList!(WitString)(_list2180); + wit.pumpkin.plugin.java_packets.common.CPlayerPosition _record2182 = { + teleportId: cast(int)(*(cast(uint*)(arg0 + 40))), + position: _tuple2175, + delta: _tuple2176, + yaw: *(cast(float*)(arg0 + 96)), + pitch: *(cast(float*)(arg0 + 100)), + relatives: _witList2181, + }; + auto _payload2647 = _record2182; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cPlayerPosition(_payload2647); + break; + } + case _Tag2551.cRemovePlayerInfo: { + auto _len2184 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr2184 = _len2184 ? cast(wit.pumpkin.plugin.java_packets.common.Uuid*)(*(cast(void**)(arg0 + 40))) : null; + if (_len2184) deallocate ~= cast()_ptr2184; + auto _list2185 = WitList!(wit.pumpkin.plugin.java_packets.common.Uuid)(_ptr2184[0.._len2184]); + wit.pumpkin.plugin.java_packets.common.CRemovePlayerInfo _record2186 = { + players: _list2185, + }; + auto _payload2648 = _record2186; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cRemovePlayerInfo(_payload2648); + break; + } + case _Tag2551.cPlayerRotation: { + wit.pumpkin.plugin.java_packets.common.CPlayerRotation _record2188 = { + yaw: *(cast(float*)(arg0 + 40)), + pitch: *(cast(float*)(arg0 + 44)), + }; + auto _payload2649 = _record2188; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cPlayerRotation(_payload2649); + break; + } + case _Tag2551.cPlayerSpawnPosition: { + auto _len2190 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr2190 = _len2190 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len2190) deallocate ~= cast()_ptr2190; + auto _list2191 = WitString(_ptr2190[0.._len2190]); + auto _tuple2192 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + (40+2*size_t.sizeof)))), + cast(int)(*(cast(uint*)(arg0 + (44+2*size_t.sizeof)))), + cast(int)(*(cast(uint*)(arg0 + (48+2*size_t.sizeof)))), + ); + wit.pumpkin.plugin.java_packets.common.CPlayerSpawnPosition _record2193 = { + dimensionName: _list2191, + location: _tuple2192, + yaw: *(cast(float*)(arg0 + (52+2*size_t.sizeof))), + pitch: *(cast(float*)(arg0 + (56+2*size_t.sizeof))), + }; + auto _payload2650 = _record2193; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cPlayerSpawnPosition(_payload2650); + break; + } + case _Tag2551.cProjectilePower: { + wit.pumpkin.plugin.java_packets.common.CProjectilePower _record2195 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + xPower: *(cast(double*)(arg0 + 48)), + yPower: *(cast(double*)(arg0 + 56)), + zPower: *(cast(double*)(arg0 + 64)), + }; + auto _payload2651 = _record2195; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cProjectilePower(_payload2651); + break; + } + case _Tag2551.cRecipeBookAdd: { + wit.pumpkin.plugin.java_packets.common.CRecipeBookAdd _record2197 = { + replace: (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0, + }; + auto _payload2652 = _record2197; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cRecipeBookAdd(_payload2652); + break; + } + case _Tag2551.cRecipeBookRemove: { + auto _len2199 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr2199 = _len2199 ? cast(int*)(*(cast(void**)(arg0 + 40))) : null; + if (_len2199) deallocate ~= cast()_ptr2199; + auto _list2200 = WitList!(int)(_ptr2199[0.._len2199]); + wit.pumpkin.plugin.java_packets.common.CRecipeBookRemove _record2201 = { + recipes: _list2200, + }; + auto _payload2653 = _record2201; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cRecipeBookRemove(_payload2653); + break; + } + case _Tag2551.cRecipeBookSettings: { + wit.pumpkin.plugin.java_packets.common.CRecipeBookSettings _record2203 = { + craftingOpen: (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0, + craftingFiltering: (cast(uint)(*(cast(ubyte*)(arg0 + 41)))) != 0, + furnaceOpen: (cast(uint)(*(cast(ubyte*)(arg0 + 42)))) != 0, + furnaceFiltering: (cast(uint)(*(cast(ubyte*)(arg0 + 43)))) != 0, + blastFurnaceOpen: (cast(uint)(*(cast(ubyte*)(arg0 + 44)))) != 0, + blastFurnaceFiltering: (cast(uint)(*(cast(ubyte*)(arg0 + 45)))) != 0, + smokerOpen: (cast(uint)(*(cast(ubyte*)(arg0 + 46)))) != 0, + smokerFiltering: (cast(uint)(*(cast(ubyte*)(arg0 + 47)))) != 0, + }; + auto _payload2654 = _record2203; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cRecipeBookSettings(_payload2654); + break; + } + case _Tag2551.cRemoveEntities: { + auto _len2205 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr2205 = _len2205 ? cast(int*)(*(cast(void**)(arg0 + 40))) : null; + if (_len2205) deallocate ~= cast()_ptr2205; + auto _list2206 = WitList!(int)(_ptr2205[0.._len2205]); + wit.pumpkin.plugin.java_packets.common.CRemoveEntities _record2207 = { + entityIds: _list2206, + }; + auto _payload2655 = _record2207; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cRemoveEntities(_payload2655); + break; + } + case _Tag2551.cRemoveMobEffect: { + wit.pumpkin.plugin.java_packets.common.CRemoveMobEffect _record2209 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + effectId: cast(int)(*(cast(uint*)(arg0 + 44))), + }; + auto _payload2656 = _record2209; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cRemoveMobEffect(_payload2656); + break; + } + case _Tag2551.cRemoveResourcePack: { + Option!(wit.pumpkin.plugin.java_packets.common.Uuid) _option2214 = void; + bool _isSome2214 = (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0; + if (_isSome2214) { + wit.pumpkin.plugin.uuid.common.Uuid _record2213 = { + high: *(cast(ulong*)(arg0 + 48)), + low: *(cast(ulong*)(arg0 + 56)), + }; + + _option2214 = Option!(wit.pumpkin.plugin.java_packets.common.Uuid).makeSome(_record2213); + } else { + _option2214 = Option!(wit.pumpkin.plugin.java_packets.common.Uuid).makeNone; + } + wit.pumpkin.plugin.java_packets.common.CRemoveResourcePack _record2215 = { + uuid: _option2214, + }; + auto _payload2657 = _record2215; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cRemoveResourcePack(_payload2657); + break; + } + case _Tag2551.cResetScore: { + auto _len2217 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr2217 = _len2217 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len2217) deallocate ~= cast()_ptr2217; + auto _list2218 = WitString(_ptr2217[0.._len2217]); + Option!(WitString) _option2223 = void; + bool _isSome2223 = (cast(uint)(*(cast(ubyte*)(arg0 + (40+2*size_t.sizeof))))) != 0; + if (_isSome2223) { + auto _len2221 = *(cast(size_t*)(arg0 + (40+4*size_t.sizeof))); + auto _ptr2221 = _len2221 ? cast(char*)(*(cast(void**)(arg0 + (40+3*size_t.sizeof)))) : null; + if (_len2221) deallocate ~= cast()_ptr2221; + auto _list2222 = WitString(_ptr2221[0.._len2221]); + + _option2223 = Option!(WitString).makeSome(_list2222); + } else { + _option2223 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.java_packets.common.CResetScore _record2224 = { + entityName: _list2218, + objectiveName: _option2223, + }; + auto _payload2658 = _record2224; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cResetScore(_payload2658); + break; + } + case _Tag2551.cRespawn: { + auto _len2226 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr2226 = _len2226 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len2226) deallocate ~= cast()_ptr2226; + auto _list2227 = WitString(_ptr2226[0.._len2226]); + Option!(Tuple!(WitString, Tuple!(int, int, int))) _option2234 = void; + bool _isSome2234 = (cast(uint)(*(cast(ubyte*)(arg0 + (48+3*size_t.sizeof))))) != 0; + if (_isSome2234) { + auto _len2230 = *(cast(size_t*)(arg0 + (48+5*size_t.sizeof))); + auto _ptr2230 = _len2230 ? cast(char*)(*(cast(void**)(arg0 + (48+4*size_t.sizeof)))) : null; + if (_len2230) deallocate ~= cast()_ptr2230; + auto _list2231 = WitString(_ptr2230[0.._len2230]); + auto _tuple2232 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + (48+6*size_t.sizeof)))), + cast(int)(*(cast(uint*)(arg0 + (52+6*size_t.sizeof)))), + cast(int)(*(cast(uint*)(arg0 + (56+6*size_t.sizeof)))), + ); + auto _tuple2233 = Tuple!(WitString, Tuple!(int, int, int))( + _list2231, + _tuple2232, + ); + + _option2234 = Option!(Tuple!(WitString, Tuple!(int, int, int))).makeSome(_tuple2233); + } else { + _option2234 = Option!(Tuple!(WitString, Tuple!(int, int, int))).makeNone; + } + wit.pumpkin.plugin.java_packets.common.PlayerSpawnData _record2235 = { + dimension: _list2227, + hashedSeed: cast(long)(*(cast(ulong*)(arg0 + (40+2*size_t.sizeof)))), + gameMode: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (48+2*size_t.sizeof))))), + previousGamemode: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (49+2*size_t.sizeof))))), + debug_: (cast(uint)(*(cast(ubyte*)(arg0 + (50+2*size_t.sizeof))))) != 0, + isFlat: (cast(uint)(*(cast(ubyte*)(arg0 + (51+2*size_t.sizeof))))) != 0, + deathDimensionName: _option2234, + portalCooldown: cast(int)(*(cast(uint*)(arg0 + (56+7*size_t.sizeof)))), + sealevel: cast(int)(*(cast(uint*)(arg0 + (60+7*size_t.sizeof)))), + }; + wit.pumpkin.plugin.java_packets.common.CRespawn _record2236 = { + playerSpawnInfo: _record2235, + dataKept: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (72+6*size_t.sizeof))))), + }; + auto _payload2659 = _record2236; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cRespawn(_payload2659); + break; + } + case _Tag2551.cSelectAdvancementsTab: { + Option!(WitString) _option2242 = void; + bool _isSome2242 = (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0; + if (_isSome2242) { + auto _len2240 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _ptr2240 = _len2240 ? cast(char*)(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))) : null; + if (_len2240) deallocate ~= cast()_ptr2240; + auto _list2241 = WitString(_ptr2240[0.._len2240]); + + _option2242 = Option!(WitString).makeSome(_list2241); + } else { + _option2242 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.java_packets.common.CSelectAdvancementsTab _record2243 = { + tabId: _option2242, + }; + auto _payload2660 = _record2243; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSelectAdvancementsTab(_payload2660); + break; + } + case _Tag2551.cServerData: { + auto _len2245 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr2245 = _len2245 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len2245) deallocate ~= cast()_ptr2245; + auto _list2246 = WitString(_ptr2245[0.._len2245]); + Option!(WitString) _option2251 = void; + bool _isSome2251 = (cast(uint)(*(cast(ubyte*)(arg0 + (40+2*size_t.sizeof))))) != 0; + if (_isSome2251) { + auto _len2249 = *(cast(size_t*)(arg0 + (40+4*size_t.sizeof))); + auto _ptr2249 = _len2249 ? cast(char*)(*(cast(void**)(arg0 + (40+3*size_t.sizeof)))) : null; + if (_len2249) deallocate ~= cast()_ptr2249; + auto _list2250 = WitString(_ptr2249[0.._len2249]); + + _option2251 = Option!(WitString).makeSome(_list2250); + } else { + _option2251 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.java_packets.common.CServerData _record2252 = { + motd: _list2246, + iconBase64: _option2251, + }; + auto _payload2661 = _record2252; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cServerData(_payload2661); + break; + } + case _Tag2551.cPlayServerLinks: { + auto _listSrcPtr2257 = *(cast(void**)(arg0 + 40)); + auto _listLen2257 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _list2257 = _listLen2257 ? wit.common.mallocSlice!(WitString)(_listLen2257) : []; + assert(!_listLen2257 || _list2257.ptr); + if (_listLen2257) deallocate ~= cast(void*)_list2257.ptr; + foreach (_elem2254_idx, ref _elem2254; _list2257) { + const auto _base2254 = _listSrcPtr2257 + _elem2254_idx * (2*size_t.sizeof); + auto _len2255 = *(cast(size_t*)(_base2254 + size_t.sizeof)); + auto _ptr2255 = _len2255 ? cast(char*)(*(cast(void**)(_base2254 + 0))) : null; + if (_len2255) deallocate ~= cast()_ptr2255; + auto _list2256 = WitString(_ptr2255[0.._len2255]); + _elem2254 = _list2256; + } + if (_listLen2257) deallocate ~= _listSrcPtr2257; + auto _witList2258 = WitList!(WitString)(_list2257); + wit.pumpkin.plugin.java_packets.common.CPlayServerLinks _record2259 = { + links: _witList2258, + }; + auto _payload2662 = _record2259; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cPlayServerLinks(_payload2662); + break; + } + case _Tag2551.cSetBorderCenter: { + wit.pumpkin.plugin.java_packets.common.CSetBorderCenter _record2261 = { + x: *(cast(double*)(arg0 + 40)), + z: *(cast(double*)(arg0 + 48)), + }; + auto _payload2663 = _record2261; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSetBorderCenter(_payload2663); + break; + } + case _Tag2551.cSetBorderLerpSize: { + wit.pumpkin.plugin.java_packets.common.CSetBorderLerpSize _record2263 = { + oldDiameter: *(cast(double*)(arg0 + 40)), + newDiameter: *(cast(double*)(arg0 + 48)), + speed: cast(long)(*(cast(ulong*)(arg0 + 56))), + }; + auto _payload2664 = _record2263; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSetBorderLerpSize(_payload2664); + break; + } + case _Tag2551.cSetBorderSize: { + wit.pumpkin.plugin.java_packets.common.CSetBorderSize _record2265 = { + diameter: *(cast(double*)(arg0 + 40)), + }; + auto _payload2665 = _record2265; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSetBorderSize(_payload2665); + break; + } + case _Tag2551.cSetBorderWarningDelay: { + wit.pumpkin.plugin.java_packets.common.CSetBorderWarningDelay _record2267 = { + warningTime: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload2666 = _record2267; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSetBorderWarningDelay(_payload2666); + break; + } + case _Tag2551.cSetBorderWarningDistance: { + wit.pumpkin.plugin.java_packets.common.CSetBorderWarningDistance _record2269 = { + warningBlocks: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload2667 = _record2269; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSetBorderWarningDistance(_payload2667); + break; + } + case _Tag2551.cSetCamera: { + wit.pumpkin.plugin.java_packets.common.CSetCamera _record2271 = { + cameraId: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload2668 = _record2271; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSetCamera(_payload2668); + break; + } + case _Tag2551.cSetChunkCacheRadius: { + wit.pumpkin.plugin.java_packets.common.CSetChunkCacheRadius _record2273 = { + radius: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload2669 = _record2273; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSetChunkCacheRadius(_payload2669); + break; + } + case _Tag2551.cSetContainerContent: { + auto _listSrcPtr2278 = *(cast(void**)(arg0 + 48)); + auto _listLen2278 = *(cast(size_t*)(arg0 + (48+1*size_t.sizeof))); + auto _list2278 = _listLen2278 ? wit.common.mallocSlice!(WitString)(_listLen2278) : []; + assert(!_listLen2278 || _list2278.ptr); + if (_listLen2278) deallocate ~= cast(void*)_list2278.ptr; + foreach (_elem2275_idx, ref _elem2275; _list2278) { + const auto _base2275 = _listSrcPtr2278 + _elem2275_idx * (2*size_t.sizeof); + auto _len2276 = *(cast(size_t*)(_base2275 + size_t.sizeof)); + auto _ptr2276 = _len2276 ? cast(char*)(*(cast(void**)(_base2275 + 0))) : null; + if (_len2276) deallocate ~= cast()_ptr2276; + auto _list2277 = WitString(_ptr2276[0.._len2276]); + _elem2275 = _list2277; + } + if (_listLen2278) deallocate ~= _listSrcPtr2278; + auto _witList2279 = WitList!(WitString)(_list2278); + auto _len2280 = *(cast(size_t*)(arg0 + (48+3*size_t.sizeof))); + auto _ptr2280 = _len2280 ? cast(char*)(*(cast(void**)(arg0 + (48+2*size_t.sizeof)))) : null; + if (_len2280) deallocate ~= cast()_ptr2280; + auto _list2281 = WitString(_ptr2280[0.._len2280]); + wit.pumpkin.plugin.java_packets.common.CSetContainerContent _record2282 = { + windowId: cast(int)(*(cast(uint*)(arg0 + 40))), + stateId: cast(int)(*(cast(uint*)(arg0 + 44))), + slotData: _witList2279, + carriedItem: _list2281, + }; + auto _payload2670 = _record2282; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSetContainerContent(_payload2670); + break; + } + case _Tag2551.cSetContainerProperty: { + wit.pumpkin.plugin.java_packets.common.CSetContainerProperty _record2284 = { + windowId: cast(int)(*(cast(uint*)(arg0 + 40))), + property: cast(int)(*(cast(uint*)(arg0 + 44))), + value: cast(int)(*(cast(uint*)(arg0 + 48))), + }; + auto _payload2671 = _record2284; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSetContainerProperty(_payload2671); + break; + } + case _Tag2551.cSetContainerSlot: { + auto _len2286 = *(cast(size_t*)(arg0 + (48+2*size_t.sizeof))); + auto _ptr2286 = _len2286 ? cast(char*)(*(cast(void**)(arg0 + (48+1*size_t.sizeof)))) : null; + if (_len2286) deallocate ~= cast()_ptr2286; + auto _list2287 = WitString(_ptr2286[0.._len2286]); + wit.pumpkin.plugin.java_packets.common.CSetContainerSlot _record2288 = { + windowId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 40)))), + stateId: cast(int)(*(cast(uint*)(arg0 + 44))), + slot: cast(int)(*(cast(uint*)(arg0 + 48))), + slotData: _list2287, + }; + auto _payload2672 = _record2288; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSetContainerSlot(_payload2672); + break; + } + case _Tag2551.cSetCursorItem: { + auto _len2290 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr2290 = _len2290 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len2290) deallocate ~= cast()_ptr2290; + auto _list2291 = WitString(_ptr2290[0.._len2290]); + wit.pumpkin.plugin.java_packets.common.CSetCursorItem _record2292 = { + stack: _list2291, + }; + auto _payload2673 = _record2292; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSetCursorItem(_payload2673); + break; + } + case _Tag2551.cSetEntityLink: { + wit.pumpkin.plugin.java_packets.common.CSetEntityLink _record2294 = { + attachedEntityId: cast(int)(*(cast(uint*)(arg0 + 40))), + holdingEntityId: cast(int)(*(cast(uint*)(arg0 + 44))), + leash: (cast(uint)(*(cast(ubyte*)(arg0 + 48)))) != 0, + }; + auto _payload2674 = _record2294; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSetEntityLink(_payload2674); + break; + } + case _Tag2551.cSetEquipment: { + auto _listSrcPtr2300 = *(cast(void**)(arg0 + (40+1*size_t.sizeof))); + auto _listLen2300 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _list2300 = _listLen2300 ? wit.common.mallocSlice!(Tuple!(ubyte, WitString))(_listLen2300) : []; + assert(!_listLen2300 || _list2300.ptr); + if (_listLen2300) deallocate ~= cast(void*)_list2300.ptr; + foreach (_elem2296_idx, ref _elem2296; _list2300) { + const auto _base2296 = _listSrcPtr2300 + _elem2296_idx * (3*size_t.sizeof); + auto _len2297 = *(cast(size_t*)(_base2296 + (2*size_t.sizeof))); + auto _ptr2297 = _len2297 ? cast(char*)(*(cast(void**)(_base2296 + size_t.sizeof))) : null; + if (_len2297) deallocate ~= cast()_ptr2297; + auto _list2298 = WitString(_ptr2297[0.._len2297]); + auto _tuple2299 = Tuple!(ubyte, WitString)( + cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base2296 + 0)))), + _list2298, + ); + _elem2296 = _tuple2299; + } + if (_listLen2300) deallocate ~= _listSrcPtr2300; + auto _witList2301 = WitList!(Tuple!(ubyte, WitString))(_list2300); + wit.pumpkin.plugin.java_packets.common.CSetEquipment _record2302 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + equipment: _witList2301, + }; + auto _payload2675 = _record2302; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSetEquipment(_payload2675); + break; + } + case _Tag2551.cSetExperience: { + wit.pumpkin.plugin.java_packets.common.CSetExperience _record2304 = { + progress: *(cast(float*)(arg0 + 40)), + level: cast(int)(*(cast(uint*)(arg0 + 44))), + totalExperience: cast(int)(*(cast(uint*)(arg0 + 48))), + }; + auto _payload2676 = _record2304; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSetExperience(_payload2676); + break; + } + case _Tag2551.cSetHealth: { + wit.pumpkin.plugin.java_packets.common.CSetHealth _record2306 = { + health: *(cast(float*)(arg0 + 40)), + food: cast(int)(*(cast(uint*)(arg0 + 44))), + foodSaturation: *(cast(float*)(arg0 + 48)), + }; + auto _payload2677 = _record2306; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSetHealth(_payload2677); + break; + } + case _Tag2551.cSetPassengers: { + auto _len2308 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _ptr2308 = _len2308 ? cast(int*)(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))) : null; + if (_len2308) deallocate ~= cast()_ptr2308; + auto _list2309 = WitList!(int)(_ptr2308[0.._len2308]); + wit.pumpkin.plugin.java_packets.common.CSetPassengers _record2310 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + passengers: _list2309, + }; + auto _payload2678 = _record2310; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSetPassengers(_payload2678); + break; + } + case _Tag2551.cSetPlayerInventory: { + auto _len2312 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _ptr2312 = _len2312 ? cast(char*)(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))) : null; + if (_len2312) deallocate ~= cast()_ptr2312; + auto _list2313 = WitString(_ptr2312[0.._len2312]); + wit.pumpkin.plugin.java_packets.common.CSetPlayerInventory _record2314 = { + slot: cast(int)(*(cast(uint*)(arg0 + 40))), + item: _list2313, + }; + auto _payload2679 = _record2314; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSetPlayerInventory(_payload2679); + break; + } + case _Tag2551.cSetPlayerTeam: { + auto _len2316 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr2316 = _len2316 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len2316) deallocate ~= cast()_ptr2316; + auto _list2317 = WitString(_ptr2316[0.._len2316]); + Option!(wit.pumpkin.plugin.java_packets.common.TeamParameters) _option2331 = void; + bool _isSome2331 = (cast(uint)(*(cast(ubyte*)(arg0 + (40+3*size_t.sizeof))))) != 0; + if (_isSome2331) { + auto _len2320 = *(cast(size_t*)(arg0 + (40+5*size_t.sizeof))); + auto _ptr2320 = _len2320 ? cast(char*)(*(cast(void**)(arg0 + (40+4*size_t.sizeof)))) : null; + if (_len2320) deallocate ~= cast()_ptr2320; + auto _list2321 = WitString(_ptr2320[0.._len2320]); + auto _len2322 = *(cast(size_t*)(arg0 + (40+8*size_t.sizeof))); + auto _ptr2322 = _len2322 ? cast(char*)(*(cast(void**)(arg0 + (40+7*size_t.sizeof)))) : null; + if (_len2322) deallocate ~= cast()_ptr2322; + auto _list2323 = WitString(_ptr2322[0.._len2322]); + auto _len2324 = *(cast(size_t*)(arg0 + (40+10*size_t.sizeof))); + auto _ptr2324 = _len2324 ? cast(char*)(*(cast(void**)(arg0 + (40+9*size_t.sizeof)))) : null; + if (_len2324) deallocate ~= cast()_ptr2324; + auto _list2325 = WitString(_ptr2324[0.._len2324]); + auto _len2326 = *(cast(size_t*)(arg0 + (40+13*size_t.sizeof))); + auto _ptr2326 = _len2326 ? cast(char*)(*(cast(void**)(arg0 + (40+12*size_t.sizeof)))) : null; + if (_len2326) deallocate ~= cast()_ptr2326; + auto _list2327 = WitString(_ptr2326[0.._len2326]); + auto _len2328 = *(cast(size_t*)(arg0 + (40+15*size_t.sizeof))); + auto _ptr2328 = _len2328 ? cast(char*)(*(cast(void**)(arg0 + (40+14*size_t.sizeof)))) : null; + if (_len2328) deallocate ~= cast()_ptr2328; + auto _list2329 = WitString(_ptr2328[0.._len2328]); + wit.pumpkin.plugin.java_packets.common.TeamParameters _record2330 = { + displayName: _list2321, + options: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (40+6*size_t.sizeof))))), + nametagVisibility: _list2323, + collisionRule: _list2325, + color: cast(int)(*(cast(uint*)(arg0 + (40+11*size_t.sizeof)))), + playerPrefix: _list2327, + playerSuffix: _list2329, + }; + + _option2331 = Option!(wit.pumpkin.plugin.java_packets.common.TeamParameters).makeSome(_record2330); + } else { + _option2331 = Option!(wit.pumpkin.plugin.java_packets.common.TeamParameters).makeNone; + } + auto _listSrcPtr2335 = *(cast(void**)(arg0 + (40+16*size_t.sizeof))); + auto _listLen2335 = *(cast(size_t*)(arg0 + (40+17*size_t.sizeof))); + auto _list2335 = _listLen2335 ? wit.common.mallocSlice!(WitString)(_listLen2335) : []; + assert(!_listLen2335 || _list2335.ptr); + if (_listLen2335) deallocate ~= cast(void*)_list2335.ptr; + foreach (_elem2332_idx, ref _elem2332; _list2335) { + const auto _base2332 = _listSrcPtr2335 + _elem2332_idx * (2*size_t.sizeof); + auto _len2333 = *(cast(size_t*)(_base2332 + size_t.sizeof)); + auto _ptr2333 = _len2333 ? cast(char*)(*(cast(void**)(_base2332 + 0))) : null; + if (_len2333) deallocate ~= cast()_ptr2333; + auto _list2334 = WitString(_ptr2333[0.._len2333]); + _elem2332 = _list2334; + } + if (_listLen2335) deallocate ~= _listSrcPtr2335; + auto _witList2336 = WitList!(WitString)(_list2335); + wit.pumpkin.plugin.java_packets.common.CSetPlayerTeam _record2337 = { + teamName: _list2317, + method: cast(wit.pumpkin.plugin.java_packets.common.TeamMethod)(cast(uint)(*(cast(ubyte*)(arg0 + (40+2*size_t.sizeof))))), + parameters: _option2331, + players: _witList2336, + }; + auto _payload2680 = _record2337; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSetPlayerTeam(_payload2680); + break; + } + case _Tag2551.cSetSimulationDistance: { + wit.pumpkin.plugin.java_packets.common.CSetSimulationDistance _record2339 = { + simulationDistance: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload2681 = _record2339; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSetSimulationDistance(_payload2681); + break; + } + case _Tag2551.cUpdateTime: { + auto _len2341 = *(cast(size_t*)(arg0 + (48+1*size_t.sizeof))); + auto _ptr2341 = _len2341 ? cast(Tuple!(int, long, float, float)*)(*(cast(void**)(arg0 + 48))) : null; + if (_len2341) deallocate ~= cast()_ptr2341; + auto _list2342 = WitList!(Tuple!(int, long, float, float))(_ptr2341[0.._len2341]); + wit.pumpkin.plugin.java_packets.common.CUpdateTime _record2343 = { + gameTime: cast(long)(*(cast(ulong*)(arg0 + 40))), + clockUpdates: _list2342, + }; + auto _payload2682 = _record2343; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cUpdateTime(_payload2682); + break; + } + case _Tag2551.cTitleText: { + auto _len2345 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr2345 = _len2345 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len2345) deallocate ~= cast()_ptr2345; + auto _list2346 = WitString(_ptr2345[0.._len2345]); + wit.pumpkin.plugin.java_packets.common.CTitleText _record2347 = { + title: _list2346, + }; + auto _payload2683 = _record2347; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cTitleText(_payload2683); + break; + } + case _Tag2551.cTitleAnimation: { + wit.pumpkin.plugin.java_packets.common.CTitleAnimation _record2349 = { + fadeInTicks: cast(int)(*(cast(uint*)(arg0 + 40))), + stayTicks: cast(int)(*(cast(uint*)(arg0 + 44))), + fadeOutTicks: cast(int)(*(cast(uint*)(arg0 + 48))), + }; + auto _payload2684 = _record2349; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cTitleAnimation(_payload2684); + break; + } + case _Tag2551.cPlayShowDialog: { + auto _len2351 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr2351 = _len2351 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len2351) deallocate ~= cast()_ptr2351; + auto _list2352 = WitString(_ptr2351[0.._len2351]); + wit.pumpkin.plugin.java_packets.common.CPlayShowDialog _record2353 = { + dialog: _list2352, + }; + auto _payload2685 = _record2353; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cPlayShowDialog(_payload2685); + break; + } + case _Tag2551.cSoundEffect: { + auto _len2355 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr2355 = _len2355 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len2355) deallocate ~= cast()_ptr2355; + auto _list2356 = WitString(_ptr2355[0.._len2355]); + auto _tuple2357 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + (48+2*size_t.sizeof))), + *(cast(double*)(arg0 + (56+2*size_t.sizeof))), + *(cast(double*)(arg0 + (64+2*size_t.sizeof))), + ); + wit.pumpkin.plugin.java_packets.common.CSoundEffect _record2358 = { + soundEvent: _list2356, + soundCategory: cast(int)(*(cast(uint*)(arg0 + (40+2*size_t.sizeof)))), + position: _tuple2357, + volume: *(cast(float*)(arg0 + (72+2*size_t.sizeof))), + pitch: *(cast(float*)(arg0 + (76+2*size_t.sizeof))), + seed: *(cast(double*)(arg0 + (80+2*size_t.sizeof))), + }; + auto _payload2686 = _record2358; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSoundEffect(_payload2686); + break; + } + case _Tag2551.cSpawnEntity: { + wit.pumpkin.plugin.uuid.common.Uuid _record2360 = { + high: *(cast(ulong*)(arg0 + 48)), + low: *(cast(ulong*)(arg0 + 56)), + }; + auto _tuple2361 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 72)), + *(cast(double*)(arg0 + 80)), + *(cast(double*)(arg0 + 88)), + ); + auto _len2362 = *(cast(size_t*)(arg0 + (96+1*size_t.sizeof))); + auto _ptr2362 = _len2362 ? cast(char*)(*(cast(void**)(arg0 + 96))) : null; + if (_len2362) deallocate ~= cast()_ptr2362; + auto _list2363 = WitString(_ptr2362[0.._len2362]); + wit.pumpkin.plugin.java_packets.common.CSpawnEntity _record2364 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + entityUuid: _record2360, + rType: cast(int)(*(cast(uint*)(arg0 + 64))), + position: _tuple2361, + velocity: _list2363, + pitch: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (96+2*size_t.sizeof))))), + yaw: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (97+2*size_t.sizeof))))), + headYaw: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (98+2*size_t.sizeof))))), + data: cast(int)(*(cast(uint*)(arg0 + (100+2*size_t.sizeof)))), + }; + auto _payload2687 = _record2364; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSpawnEntity(_payload2687); + break; + } + case _Tag2551.cSpawnLivingEntity: { + wit.pumpkin.plugin.uuid.common.Uuid _record2366 = { + high: *(cast(ulong*)(arg0 + 48)), + low: *(cast(ulong*)(arg0 + 56)), + }; + auto _tuple2367 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 72)), + *(cast(double*)(arg0 + 80)), + *(cast(double*)(arg0 + 88)), + ); + auto _len2368 = *(cast(size_t*)(arg0 + (96+2*size_t.sizeof))); + auto _ptr2368 = _len2368 ? cast(char*)(*(cast(void**)(arg0 + (96+1*size_t.sizeof)))) : null; + if (_len2368) deallocate ~= cast()_ptr2368; + auto _list2369 = WitString(_ptr2368[0.._len2368]); + Option!(WitList!(ubyte)) _option2374 = void; + bool _isSome2374 = (cast(uint)(*(cast(ubyte*)(arg0 + (96+3*size_t.sizeof))))) != 0; + if (_isSome2374) { + auto _len2372 = *(cast(size_t*)(arg0 + (96+5*size_t.sizeof))); + auto _ptr2372 = _len2372 ? cast(ubyte*)(*(cast(void**)(arg0 + (96+4*size_t.sizeof)))) : null; + if (_len2372) deallocate ~= cast()_ptr2372; + auto _list2373 = WitList!(ubyte)(_ptr2372[0.._len2372]); + + _option2374 = Option!(WitList!(ubyte)).makeSome(_list2373); + } else { + _option2374 = Option!(WitList!(ubyte)).makeNone; + } + wit.pumpkin.plugin.java_packets.common.CSpawnLivingEntity _record2375 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + entityUuid: _record2366, + rType: cast(int)(*(cast(uint*)(arg0 + 64))), + position: _tuple2367, + yaw: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 96)))), + pitch: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 97)))), + headYaw: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 98)))), + velocity: _list2369, + metadata: _option2374, + }; + auto _payload2688 = _record2375; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSpawnLivingEntity(_payload2688); + break; + } + case _Tag2551.cSpawnPainting: { + wit.pumpkin.plugin.uuid.common.Uuid _record2377 = { + high: *(cast(ulong*)(arg0 + 48)), + low: *(cast(ulong*)(arg0 + 56)), + }; + auto _len2378 = *(cast(size_t*)(arg0 + (64+1*size_t.sizeof))); + auto _ptr2378 = _len2378 ? cast(char*)(*(cast(void**)(arg0 + 64))) : null; + if (_len2378) deallocate ~= cast()_ptr2378; + auto _list2379 = WitString(_ptr2378[0.._len2378]); + auto _tuple2380 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + (68+2*size_t.sizeof)))), + cast(int)(*(cast(uint*)(arg0 + (72+2*size_t.sizeof)))), + cast(int)(*(cast(uint*)(arg0 + (76+2*size_t.sizeof)))), + ); + wit.pumpkin.plugin.java_packets.common.CSpawnPainting _record2381 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + uuid: _record2377, + title: _list2379, + variant: cast(int)(*(cast(uint*)(arg0 + (64+2*size_t.sizeof)))), + location: _tuple2380, + direction: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (80+2*size_t.sizeof))))), + }; + auto _payload2689 = _record2381; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSpawnPainting(_payload2689); + break; + } + case _Tag2551.cStartConfiguration: { + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cStartConfiguration(); + break; + } + case _Tag2551.cStopSound: { + Option!(WitString) _option2388 = void; + bool _isSome2388 = (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0; + if (_isSome2388) { + auto _len2386 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _ptr2386 = _len2386 ? cast(char*)(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))) : null; + if (_len2386) deallocate ~= cast()_ptr2386; + auto _list2387 = WitString(_ptr2386[0.._len2386]); + + _option2388 = Option!(WitString).makeSome(_list2387); + } else { + _option2388 = Option!(WitString).makeNone; + } + Option!(WitString) _option2393 = void; + bool _isSome2393 = (cast(uint)(*(cast(ubyte*)(arg0 + (40+3*size_t.sizeof))))) != 0; + if (_isSome2393) { + auto _len2391 = *(cast(size_t*)(arg0 + (40+5*size_t.sizeof))); + auto _ptr2391 = _len2391 ? cast(char*)(*(cast(void**)(arg0 + (40+4*size_t.sizeof)))) : null; + if (_len2391) deallocate ~= cast()_ptr2391; + auto _list2392 = WitString(_ptr2391[0.._len2391]); + + _option2393 = Option!(WitString).makeSome(_list2392); + } else { + _option2393 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.java_packets.common.CStopSound _record2394 = { + soundId: _option2388, + category: _option2393, + }; + auto _payload2691 = _record2394; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cStopSound(_payload2691); + break; + } + case _Tag2551.cStoreCookie: { + auto _len2396 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr2396 = _len2396 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len2396) deallocate ~= cast()_ptr2396; + auto _list2397 = WitString(_ptr2396[0.._len2396]); + auto _len2398 = *(cast(size_t*)(arg0 + (40+3*size_t.sizeof))); + auto _ptr2398 = _len2398 ? cast(ubyte*)(*(cast(void**)(arg0 + (40+2*size_t.sizeof)))) : null; + if (_len2398) deallocate ~= cast()_ptr2398; + auto _list2399 = WitList!(ubyte)(_ptr2398[0.._len2398]); + wit.pumpkin.plugin.java_packets.common.CStoreCookie _record2400 = { + key: _list2397, + payload: _list2399, + }; + auto _payload2692 = _record2400; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cStoreCookie(_payload2692); + break; + } + case _Tag2551.cSubtitle: { + auto _len2402 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr2402 = _len2402 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len2402) deallocate ~= cast()_ptr2402; + auto _list2403 = WitString(_ptr2402[0.._len2402]); + wit.pumpkin.plugin.java_packets.common.CSubtitle _record2404 = { + subtitle: _list2403, + }; + auto _payload2693 = _record2404; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cSubtitle(_payload2693); + break; + } + case _Tag2551.cTabList: { + auto _len2406 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr2406 = _len2406 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len2406) deallocate ~= cast()_ptr2406; + auto _list2407 = WitString(_ptr2406[0.._len2406]); + auto _len2408 = *(cast(size_t*)(arg0 + (40+3*size_t.sizeof))); + auto _ptr2408 = _len2408 ? cast(char*)(*(cast(void**)(arg0 + (40+2*size_t.sizeof)))) : null; + if (_len2408) deallocate ~= cast()_ptr2408; + auto _list2409 = WitString(_ptr2408[0.._len2408]); + wit.pumpkin.plugin.java_packets.common.CTabList _record2410 = { + header: _list2407, + footer: _list2409, + }; + auto _payload2694 = _record2410; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cTabList(_payload2694); + break; + } + case _Tag2551.cTagQueryResponse: { + auto _len2412 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _ptr2412 = _len2412 ? cast(ubyte*)(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))) : null; + if (_len2412) deallocate ~= cast()_ptr2412; + auto _list2413 = WitList!(ubyte)(_ptr2412[0.._len2412]); + wit.pumpkin.plugin.java_packets.common.CTagQueryResponse _record2414 = { + transactionId: cast(int)(*(cast(uint*)(arg0 + 40))), + nbtBytes: _list2413, + }; + auto _payload2695 = _record2414; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cTagQueryResponse(_payload2695); + break; + } + case _Tag2551.cTakeItemEntity: { + wit.pumpkin.plugin.java_packets.common.CTakeItemEntity _record2416 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + collectorEntityId: cast(int)(*(cast(uint*)(arg0 + 44))), + stackAmount: cast(int)(*(cast(uint*)(arg0 + 48))), + }; + auto _payload2696 = _record2416; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cTakeItemEntity(_payload2696); + break; + } + case _Tag2551.cTeleportEntity: { + auto _tuple2418 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 48)), + *(cast(double*)(arg0 + 56)), + *(cast(double*)(arg0 + 64)), + ); + auto _tuple2419 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 72)), + *(cast(double*)(arg0 + 80)), + *(cast(double*)(arg0 + 88)), + ); + auto _listSrcPtr2423 = *(cast(void**)(arg0 + 104)); + auto _listLen2423 = *(cast(size_t*)(arg0 + (104+1*size_t.sizeof))); + auto _list2423 = _listLen2423 ? wit.common.mallocSlice!(WitString)(_listLen2423) : []; + assert(!_listLen2423 || _list2423.ptr); + if (_listLen2423) deallocate ~= cast(void*)_list2423.ptr; + foreach (_elem2420_idx, ref _elem2420; _list2423) { + const auto _base2420 = _listSrcPtr2423 + _elem2420_idx * (2*size_t.sizeof); + auto _len2421 = *(cast(size_t*)(_base2420 + size_t.sizeof)); + auto _ptr2421 = _len2421 ? cast(char*)(*(cast(void**)(_base2420 + 0))) : null; + if (_len2421) deallocate ~= cast()_ptr2421; + auto _list2422 = WitString(_ptr2421[0.._len2421]); + _elem2420 = _list2422; + } + if (_listLen2423) deallocate ~= _listSrcPtr2423; + auto _witList2424 = WitList!(WitString)(_list2423); + wit.pumpkin.plugin.java_packets.common.CTeleportEntity _record2425 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + position: _tuple2418, + delta: _tuple2419, + yaw: *(cast(float*)(arg0 + 96)), + pitch: *(cast(float*)(arg0 + 100)), + relatives: _witList2424, + onGround: (cast(uint)(*(cast(ubyte*)(arg0 + (104+2*size_t.sizeof))))) != 0, + }; + auto _payload2697 = _record2425; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cTeleportEntity(_payload2697); + break; + } + case _Tag2551.cTestInstanceBlockStatus: { + auto _tuple2427 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 40))), + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + ); + Option!(WitString) _option2432 = void; + bool _isSome2432 = (cast(uint)(*(cast(ubyte*)(arg0 + 56)))) != 0; + if (_isSome2432) { + auto _len2430 = *(cast(size_t*)(arg0 + (56+2*size_t.sizeof))); + auto _ptr2430 = _len2430 ? cast(char*)(*(cast(void**)(arg0 + (56+1*size_t.sizeof)))) : null; + if (_len2430) deallocate ~= cast()_ptr2430; + auto _list2431 = WitString(_ptr2430[0.._len2430]); + + _option2432 = Option!(WitString).makeSome(_list2431); + } else { + _option2432 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.java_packets.common.CTestInstanceBlockStatus _record2433 = { + pos: _tuple2427, + status: cast(int)(*(cast(uint*)(arg0 + 52))), + message: _option2432, + }; + auto _payload2698 = _record2433; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cTestInstanceBlockStatus(_payload2698); + break; + } + case _Tag2551.cTickingState: { + wit.pumpkin.plugin.java_packets.common.CTickingState _record2435 = { + tickRate: *(cast(float*)(arg0 + 40)), + isFrozen: (cast(uint)(*(cast(ubyte*)(arg0 + 44)))) != 0, + }; + auto _payload2699 = _record2435; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cTickingState(_payload2699); + break; + } + case _Tag2551.cTickingStep: { + wit.pumpkin.plugin.java_packets.common.CTickingStep _record2437 = { + tickSteps: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload2700 = _record2437; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cTickingStep(_payload2700); + break; + } + case _Tag2551.cTransfer: { + auto _len2439 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr2439 = _len2439 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len2439) deallocate ~= cast()_ptr2439; + auto _list2440 = WitString(_ptr2439[0.._len2439]); + wit.pumpkin.plugin.java_packets.common.CTransfer _record2441 = { + host: _list2440, + port: cast(int)(*(cast(uint*)(arg0 + (40+2*size_t.sizeof)))), + }; + auto _payload2701 = _record2441; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cTransfer(_payload2701); + break; + } + case _Tag2551.cUnloadChunk: { + wit.pumpkin.plugin.java_packets.common.CUnloadChunk _record2443 = { + x: cast(int)(*(cast(uint*)(arg0 + 40))), + z: cast(int)(*(cast(uint*)(arg0 + 44))), + }; + auto _payload2702 = _record2443; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cUnloadChunk(_payload2702); + break; + } + case _Tag2551.cUpdateAdvancements: { + auto _listSrcPtr2448 = *(cast(void**)(arg0 + (40+1*size_t.sizeof))); + auto _listLen2448 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _list2448 = _listLen2448 ? wit.common.mallocSlice!(WitString)(_listLen2448) : []; + assert(!_listLen2448 || _list2448.ptr); + if (_listLen2448) deallocate ~= cast(void*)_list2448.ptr; + foreach (_elem2445_idx, ref _elem2445; _list2448) { + const auto _base2445 = _listSrcPtr2448 + _elem2445_idx * (2*size_t.sizeof); + auto _len2446 = *(cast(size_t*)(_base2445 + size_t.sizeof)); + auto _ptr2446 = _len2446 ? cast(char*)(*(cast(void**)(_base2445 + 0))) : null; + if (_len2446) deallocate ~= cast()_ptr2446; + auto _list2447 = WitString(_ptr2446[0.._len2446]); + _elem2445 = _list2447; + } + if (_listLen2448) deallocate ~= _listSrcPtr2448; + auto _witList2449 = WitList!(WitString)(_list2448); + auto _listSrcPtr2453 = *(cast(void**)(arg0 + (40+3*size_t.sizeof))); + auto _listLen2453 = *(cast(size_t*)(arg0 + (40+4*size_t.sizeof))); + auto _list2453 = _listLen2453 ? wit.common.mallocSlice!(WitString)(_listLen2453) : []; + assert(!_listLen2453 || _list2453.ptr); + if (_listLen2453) deallocate ~= cast(void*)_list2453.ptr; + foreach (_elem2450_idx, ref _elem2450; _list2453) { + const auto _base2450 = _listSrcPtr2453 + _elem2450_idx * (2*size_t.sizeof); + auto _len2451 = *(cast(size_t*)(_base2450 + size_t.sizeof)); + auto _ptr2451 = _len2451 ? cast(char*)(*(cast(void**)(_base2450 + 0))) : null; + if (_len2451) deallocate ~= cast()_ptr2451; + auto _list2452 = WitString(_ptr2451[0.._len2451]); + _elem2450 = _list2452; + } + if (_listLen2453) deallocate ~= _listSrcPtr2453; + auto _witList2454 = WitList!(WitString)(_list2453); + auto _listSrcPtr2458 = *(cast(void**)(arg0 + (40+5*size_t.sizeof))); + auto _listLen2458 = *(cast(size_t*)(arg0 + (40+6*size_t.sizeof))); + auto _list2458 = _listLen2458 ? wit.common.mallocSlice!(WitString)(_listLen2458) : []; + assert(!_listLen2458 || _list2458.ptr); + if (_listLen2458) deallocate ~= cast(void*)_list2458.ptr; + foreach (_elem2455_idx, ref _elem2455; _list2458) { + const auto _base2455 = _listSrcPtr2458 + _elem2455_idx * (2*size_t.sizeof); + auto _len2456 = *(cast(size_t*)(_base2455 + size_t.sizeof)); + auto _ptr2456 = _len2456 ? cast(char*)(*(cast(void**)(_base2455 + 0))) : null; + if (_len2456) deallocate ~= cast()_ptr2456; + auto _list2457 = WitString(_ptr2456[0.._len2456]); + _elem2455 = _list2457; + } + if (_listLen2458) deallocate ~= _listSrcPtr2458; + auto _witList2459 = WitList!(WitString)(_list2458); + wit.pumpkin.plugin.java_packets.common.CUpdateAdvancements _record2460 = { + reset: (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0, + added: _witList2449, + removed: _witList2454, + progress: _witList2459, + showAdvancements: (cast(uint)(*(cast(ubyte*)(arg0 + (40+7*size_t.sizeof))))) != 0, + }; + auto _payload2703 = _record2460; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cUpdateAdvancements(_payload2703); + break; + } + case _Tag2551.cUpdateAttributes: { + auto _listSrcPtr2470 = *(cast(void**)(arg0 + (40+1*size_t.sizeof))); + auto _listLen2470 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _list2470 = _listLen2470 ? wit.common.mallocSlice!(wit.pumpkin.plugin.java_packets.common.Property)(_listLen2470) : []; + assert(!_listLen2470 || _list2470.ptr); + if (_listLen2470) deallocate ~= cast(void*)_list2470.ptr; + foreach (_elem2462_idx, ref _elem2462; _list2470) { + const auto _base2462 = _listSrcPtr2470 + _elem2462_idx * (16+2*size_t.sizeof); + auto _listSrcPtr2467 = *(cast(void**)(_base2462 + 16)); + auto _listLen2467 = *(cast(size_t*)(_base2462 + (16+1*size_t.sizeof))); + auto _list2467 = _listLen2467 ? wit.common.mallocSlice!(wit.pumpkin.plugin.java_packets.common.AttributeModifier)(_listLen2467) : []; + assert(!_listLen2467 || _list2467.ptr); + if (_listLen2467) deallocate ~= cast(void*)_list2467.ptr; + foreach (_elem2463_idx, ref _elem2463; _list2467) { + const auto _base2463 = _listSrcPtr2467 + _elem2463_idx * (16+2*size_t.sizeof); + auto _len2464 = *(cast(size_t*)(_base2463 + size_t.sizeof)); + auto _ptr2464 = _len2464 ? cast(char*)(*(cast(void**)(_base2463 + 0))) : null; + if (_len2464) deallocate ~= cast()_ptr2464; + auto _list2465 = WitString(_ptr2464[0.._len2464]); + wit.pumpkin.plugin.java_packets.common.AttributeModifier _record2466 = { + id: _list2465, + amount: *(cast(double*)(_base2463 + (2*size_t.sizeof))), + operation: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base2463 + (8+2*size_t.sizeof))))), + }; + _elem2463 = _record2466; + } + if (_listLen2467) deallocate ~= _listSrcPtr2467; + auto _witList2468 = WitList!(wit.pumpkin.plugin.java_packets.common.AttributeModifier)(_list2467); + wit.pumpkin.plugin.java_packets.common.Property _record2469 = { + id: cast(int)(*(cast(uint*)(_base2462 + 0))), + value: *(cast(double*)(_base2462 + 8)), + modifiers: _witList2468, + }; + _elem2462 = _record2469; + } + if (_listLen2470) deallocate ~= _listSrcPtr2470; + auto _witList2471 = WitList!(wit.pumpkin.plugin.java_packets.common.Property)(_list2470); + wit.pumpkin.plugin.java_packets.common.CUpdateAttributes _record2472 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + properties: _witList2471, + }; + auto _payload2704 = _record2472; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cUpdateAttributes(_payload2704); + break; + } + case _Tag2551.cUpdateEntityPos: { + auto _tuple2474 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 48)), + *(cast(double*)(arg0 + 56)), + *(cast(double*)(arg0 + 64)), + ); + wit.pumpkin.plugin.java_packets.common.CUpdateEntityPos _record2475 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + delta: _tuple2474, + onGround: (cast(uint)(*(cast(ubyte*)(arg0 + 72)))) != 0, + }; + auto _payload2705 = _record2475; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cUpdateEntityPos(_payload2705); + break; + } + case _Tag2551.cUpdateEntityPosRot: { + auto _tuple2477 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 48)), + *(cast(double*)(arg0 + 56)), + *(cast(double*)(arg0 + 64)), + ); + wit.pumpkin.plugin.java_packets.common.CUpdateEntityPosRot _record2478 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + delta: _tuple2477, + yaw: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 72)))), + pitch: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 73)))), + onGround: (cast(uint)(*(cast(ubyte*)(arg0 + 74)))) != 0, + }; + auto _payload2706 = _record2478; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cUpdateEntityPosRot(_payload2706); + break; + } + case _Tag2551.cUpdateEntityRot: { + wit.pumpkin.plugin.java_packets.common.CUpdateEntityRot _record2480 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + yaw: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 44)))), + pitch: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 45)))), + onGround: (cast(uint)(*(cast(ubyte*)(arg0 + 46)))) != 0, + }; + auto _payload2707 = _record2480; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cUpdateEntityRot(_payload2707); + break; + } + case _Tag2551.cUpdateMobEffect: { + wit.pumpkin.plugin.java_packets.common.CUpdateMobEffect _record2482 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + effectId: cast(int)(*(cast(uint*)(arg0 + 44))), + amplifier: cast(int)(*(cast(uint*)(arg0 + 48))), + duration: cast(int)(*(cast(uint*)(arg0 + 52))), + flags: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 56)))), + }; + auto _payload2708 = _record2482; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cUpdateMobEffect(_payload2708); + break; + } + case _Tag2551.cUpdateObjectives: { + auto _len2484 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr2484 = _len2484 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len2484) deallocate ~= cast()_ptr2484; + auto _list2485 = WitString(_ptr2484[0.._len2484]); + auto _len2486 = *(cast(size_t*)(arg0 + (40+4*size_t.sizeof))); + auto _ptr2486 = _len2486 ? cast(char*)(*(cast(void**)(arg0 + (40+3*size_t.sizeof)))) : null; + if (_len2486) deallocate ~= cast()_ptr2486; + auto _list2487 = WitString(_ptr2486[0.._len2486]); + Option!(WitString) _option2492 = void; + bool _isSome2492 = (cast(uint)(*(cast(ubyte*)(arg0 + (40+6*size_t.sizeof))))) != 0; + if (_isSome2492) { + auto _len2490 = *(cast(size_t*)(arg0 + (40+8*size_t.sizeof))); + auto _ptr2490 = _len2490 ? cast(char*)(*(cast(void**)(arg0 + (40+7*size_t.sizeof)))) : null; + if (_len2490) deallocate ~= cast()_ptr2490; + auto _list2491 = WitString(_ptr2490[0.._len2490]); + + _option2492 = Option!(WitString).makeSome(_list2491); + } else { + _option2492 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.java_packets.common.CUpdateObjectives _record2493 = { + objectiveName: _list2485, + mode: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (40+2*size_t.sizeof))))), + displayName: _list2487, + renderType: cast(int)(*(cast(uint*)(arg0 + (40+5*size_t.sizeof)))), + numberFormat: _option2492, + }; + auto _payload2709 = _record2493; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cUpdateObjectives(_payload2709); + break; + } + case _Tag2551.cUpdateRecipes: { + auto _len2495 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr2495 = _len2495 ? cast(ubyte*)(*(cast(void**)(arg0 + 40))) : null; + if (_len2495) deallocate ~= cast()_ptr2495; + auto _list2496 = WitList!(ubyte)(_ptr2495[0.._len2495]); + wit.pumpkin.plugin.java_packets.common.CUpdateRecipes _record2497 = { + rawData: _list2496, + }; + auto _payload2710 = _record2497; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cUpdateRecipes(_payload2710); + break; + } + case _Tag2551.cUpdateScore: { + auto _len2499 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr2499 = _len2499 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len2499) deallocate ~= cast()_ptr2499; + auto _list2500 = WitString(_ptr2499[0.._len2499]); + auto _len2501 = *(cast(size_t*)(arg0 + (40+3*size_t.sizeof))); + auto _ptr2501 = _len2501 ? cast(char*)(*(cast(void**)(arg0 + (40+2*size_t.sizeof)))) : null; + if (_len2501) deallocate ~= cast()_ptr2501; + auto _list2502 = WitString(_ptr2501[0.._len2501]); + Option!(WitString) _option2507 = void; + bool _isSome2507 = (cast(uint)(*(cast(ubyte*)(arg0 + (40+5*size_t.sizeof))))) != 0; + if (_isSome2507) { + auto _len2505 = *(cast(size_t*)(arg0 + (40+7*size_t.sizeof))); + auto _ptr2505 = _len2505 ? cast(char*)(*(cast(void**)(arg0 + (40+6*size_t.sizeof)))) : null; + if (_len2505) deallocate ~= cast()_ptr2505; + auto _list2506 = WitString(_ptr2505[0.._len2505]); + + _option2507 = Option!(WitString).makeSome(_list2506); + } else { + _option2507 = Option!(WitString).makeNone; + } + Option!(WitString) _option2512 = void; + bool _isSome2512 = (cast(uint)(*(cast(ubyte*)(arg0 + (40+8*size_t.sizeof))))) != 0; + if (_isSome2512) { + auto _len2510 = *(cast(size_t*)(arg0 + (40+10*size_t.sizeof))); + auto _ptr2510 = _len2510 ? cast(char*)(*(cast(void**)(arg0 + (40+9*size_t.sizeof)))) : null; + if (_len2510) deallocate ~= cast()_ptr2510; + auto _list2511 = WitString(_ptr2510[0.._len2510]); + + _option2512 = Option!(WitString).makeSome(_list2511); + } else { + _option2512 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.java_packets.common.CUpdateScore _record2513 = { + entityName: _list2500, + objectiveName: _list2502, + value: cast(int)(*(cast(uint*)(arg0 + (40+4*size_t.sizeof)))), + displayName: _option2507, + numberFormat: _option2512, + }; + auto _payload2711 = _record2513; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cUpdateScore(_payload2711); + break; + } + case _Tag2551.cUseBed: { + auto _tuple2515 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + cast(int)(*(cast(uint*)(arg0 + 52))), + ); + wit.pumpkin.plugin.java_packets.common.CUseBed _record2516 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 40))), + location: _tuple2515, + }; + auto _payload2712 = _record2516; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cUseBed(_payload2712); + break; + } + case _Tag2551.cWaypoint: { + wit.pumpkin.plugin.uuid.common.Uuid _record2518 = { + high: *(cast(ulong*)(arg0 + 48)), + low: *(cast(ulong*)(arg0 + 56)), + }; + Option!(wit.pumpkin.plugin.java_packets.common.WaypointIcon) _option2527 = void; + bool _isSome2527 = (cast(uint)(*(cast(ubyte*)(arg0 + 64)))) != 0; + if (_isSome2527) { + Option!(WitString) _option2525 = void; + bool _isSome2525 = (cast(uint)(*(cast(ubyte*)(arg0 + (64+1*size_t.sizeof))))) != 0; + if (_isSome2525) { + auto _len2523 = *(cast(size_t*)(arg0 + (64+3*size_t.sizeof))); + auto _ptr2523 = _len2523 ? cast(char*)(*(cast(void**)(arg0 + (64+2*size_t.sizeof)))) : null; + if (_len2523) deallocate ~= cast()_ptr2523; + auto _list2524 = WitString(_ptr2523[0.._len2523]); + + _option2525 = Option!(WitString).makeSome(_list2524); + } else { + _option2525 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.java_packets.common.WaypointIcon _record2526 = { + style: _option2525, + color: cast(int)(*(cast(uint*)(arg0 + (64+4*size_t.sizeof)))), + }; + + _option2527 = Option!(wit.pumpkin.plugin.java_packets.common.WaypointIcon).makeSome(_record2526); + } else { + _option2527 = Option!(wit.pumpkin.plugin.java_packets.common.WaypointIcon).makeNone; + } + wit.pumpkin.plugin.java_packets.common.WaypointTarget _variant2534 = void; + auto _tag2534 = cast(uint)(*(cast(ubyte*)(arg0 + (64+5*size_t.sizeof)))); + alias _Tag2534 = wit.pumpkin.plugin.java_packets.common.WaypointTarget.Tag; + final switch (cast(wit.pumpkin.plugin.java_packets.common.WaypointTarget.Tag)_tag2534) { + case _Tag2534.position: { + auto _tuple2529 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + (68+5*size_t.sizeof)))), + cast(int)(*(cast(uint*)(arg0 + (72+5*size_t.sizeof)))), + cast(int)(*(cast(uint*)(arg0 + (76+5*size_t.sizeof)))), + ); + auto _payload2535 = _tuple2529; + _variant2534 = wit.pumpkin.plugin.java_packets.common.WaypointTarget.position(_payload2535); + break; + } + case _Tag2534.chunk: { + wit.pumpkin.plugin.java_packets.common.WaypointTargetChunk _record2531 = { + x: cast(int)(*(cast(uint*)(arg0 + (68+5*size_t.sizeof)))), + z: cast(int)(*(cast(uint*)(arg0 + (72+5*size_t.sizeof)))), + }; + auto _payload2536 = _record2531; + _variant2534 = wit.pumpkin.plugin.java_packets.common.WaypointTarget.chunk(_payload2536); + break; + } + case _Tag2534.azimuth: { + auto _payload2537 = *(cast(float*)(arg0 + (68+5*size_t.sizeof))); + _variant2534 = wit.pumpkin.plugin.java_packets.common.WaypointTarget.azimuth(_payload2537); + break; + } + case _Tag2534.empty: { + _variant2534 = wit.pumpkin.plugin.java_packets.common.WaypointTarget.empty(); + break; + } + } + wit.pumpkin.plugin.java_packets.common.TrackedWaypoint _record2539 = { + identifier: _record2518, + icon: _option2527, + target: _variant2534, + }; + wit.pumpkin.plugin.java_packets.common.CWaypoint _record2540 = { + operation: cast(wit.pumpkin.plugin.java_packets.common.WaypointOperation)(cast(uint)(*(cast(ubyte*)(arg0 + 40)))), + waypoint: _record2539, + }; + auto _payload2713 = _record2540; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cWaypoint(_payload2713); + break; + } + case _Tag2551.cWorldEvent: { + auto _tuple2542 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + cast(int)(*(cast(uint*)(arg0 + 52))), + ); + wit.pumpkin.plugin.java_packets.common.CWorldEvent _record2543 = { + event: cast(int)(*(cast(uint*)(arg0 + 40))), + location: _tuple2542, + data: cast(int)(*(cast(uint*)(arg0 + 56))), + disableRelativeVolume: (cast(uint)(*(cast(ubyte*)(arg0 + 60)))) != 0, + }; + auto _payload2714 = _record2543; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.cWorldEvent(_payload2714); + break; + } + case _Tag2551.statusCPingResponse: { + wit.pumpkin.plugin.java_packets.common.StatusCPingResponse _record2545 = { + payload: cast(long)(*(cast(ulong*)(arg0 + 40))), + }; + auto _payload2715 = _record2545; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.statusCPingResponse(_payload2715); + break; + } + case _Tag2551.statusCStatusResponse: { + auto _len2547 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr2547 = _len2547 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len2547) deallocate ~= cast()_ptr2547; + auto _list2548 = WitString(_ptr2547[0.._len2547]); + wit.pumpkin.plugin.java_packets.common.StatusCStatusResponse _record2549 = { + jsonResponse: _list2548, + }; + auto _payload2716 = _record2549; + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.statusCStatusResponse(_payload2716); + break; + } + case _Tag2551.unknown: { + _variant2551 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.unknown(); + break; + } + } + auto _payload3520 = _variant2551; + _variant3519 = wit.pumpkin.plugin.event.common.ClientboundPacket.java(_payload3520); + break; + } + case _Tag3519.bedrock: { + wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket _variant3458 = void; + auto _tag3458 = cast(uint)(*(cast(ubyte*)(arg0 + 32))); + alias _Tag3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.Tag; + final switch (cast(wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.Tag)_tag3458) { + case _Tag3458.cAddActor: { + auto _len2720 = *(cast(size_t*)(arg0 + (56+1*size_t.sizeof))); + auto _ptr2720 = _len2720 ? cast(char*)(*(cast(void**)(arg0 + 56))) : null; + if (_len2720) deallocate ~= cast()_ptr2720; + auto _list2721 = WitString(_ptr2720[0.._len2720]); + auto _tuple2722 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + (56+2*size_t.sizeof))), + *(cast(double*)(arg0 + (64+2*size_t.sizeof))), + *(cast(double*)(arg0 + (72+2*size_t.sizeof))), + ); + auto _tuple2723 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + (80+2*size_t.sizeof))), + *(cast(double*)(arg0 + (88+2*size_t.sizeof))), + *(cast(double*)(arg0 + (96+2*size_t.sizeof))), + ); + auto _tuple2724 = Tuple!(double, double)( + *(cast(double*)(arg0 + (104+2*size_t.sizeof))), + *(cast(double*)(arg0 + (112+2*size_t.sizeof))), + ); + auto _listSrcPtr2729 = *(cast(void**)(arg0 + (128+2*size_t.sizeof))); + auto _listLen2729 = *(cast(size_t*)(arg0 + (128+3*size_t.sizeof))); + auto _list2729 = _listLen2729 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.SyncedAttribute)(_listLen2729) : []; + assert(!_listLen2729 || _list2729.ptr); + if (_listLen2729) deallocate ~= cast(void*)_list2729.ptr; + foreach (_elem2725_idx, ref _elem2725; _list2729) { + const auto _base2725 = _listSrcPtr2729 + _elem2725_idx * (8+3*size_t.sizeof); + auto _len2726 = *(cast(size_t*)(_base2725 + size_t.sizeof)); + auto _ptr2726 = _len2726 ? cast(char*)(*(cast(void**)(_base2725 + 0))) : null; + if (_len2726) deallocate ~= cast()_ptr2726; + auto _list2727 = WitString(_ptr2726[0.._len2726]); + wit.pumpkin.plugin.bedrock_packets.common.SyncedAttribute _record2728 = { + attributeName: _list2727, + minValue: *(cast(float*)(_base2725 + (2*size_t.sizeof))), + currentValue: *(cast(float*)(_base2725 + (4+2*size_t.sizeof))), + maxValue: *(cast(float*)(_base2725 + (8+2*size_t.sizeof))), + }; + _elem2725 = _record2728; + } + if (_listLen2729) deallocate ~= _listSrcPtr2729; + auto _witList2730 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.SyncedAttribute)(_list2729); + auto _len2731 = *(cast(size_t*)(arg0 + (128+5*size_t.sizeof))); + auto _ptr2731 = _len2731 ? cast(char*)(*(cast(void**)(arg0 + (128+4*size_t.sizeof)))) : null; + if (_len2731) deallocate ~= cast()_ptr2731; + auto _list2732 = WitString(_ptr2731[0.._len2731]); + auto _len2733 = *(cast(size_t*)(arg0 + (128+7*size_t.sizeof))); + auto _ptr2733 = _len2733 ? cast(Tuple!(int, int)*)(*(cast(void**)(arg0 + (128+6*size_t.sizeof)))) : null; + if (_len2733) deallocate ~= cast()_ptr2733; + auto _list2734 = WitList!(Tuple!(int, int))(_ptr2733[0.._len2733]); + auto _len2735 = *(cast(size_t*)(arg0 + (128+9*size_t.sizeof))); + auto _ptr2735 = _len2735 ? cast(Tuple!(int, float)*)(*(cast(void**)(arg0 + (128+8*size_t.sizeof)))) : null; + if (_len2735) deallocate ~= cast()_ptr2735; + auto _list2736 = WitList!(Tuple!(int, float))(_ptr2735[0.._len2735]); + wit.pumpkin.plugin.bedrock_packets.common.PropertySyncData _record2737 = { + intEntriesList: _list2734, + floatEntriesList: _list2736, + }; + auto _listSrcPtr2740 = *(cast(void**)(arg0 + (128+10*size_t.sizeof))); + auto _listLen2740 = *(cast(size_t*)(arg0 + (128+11*size_t.sizeof))); + auto _list2740 = _listLen2740 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.ActorLink)(_listLen2740) : []; + assert(!_listLen2740 || _list2740.ptr); + if (_listLen2740) deallocate ~= cast(void*)_list2740.ptr; + foreach (_elem2738_idx, ref _elem2738; _list2740) { + const auto _base2738 = _listSrcPtr2740 + _elem2738_idx * 24; + wit.pumpkin.plugin.bedrock_packets.common.ActorLink _record2739 = { + riddenUniqueId: cast(long)(*(cast(ulong*)(_base2738 + 0))), + riderUniqueId: cast(long)(*(cast(ulong*)(_base2738 + 8))), + linkType: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base2738 + 16)))), + immediate: (cast(uint)(*(cast(ubyte*)(_base2738 + 17)))) != 0, + riderInitiated: (cast(uint)(*(cast(ubyte*)(_base2738 + 18)))) != 0, + vehicleAngularVelocity: *(cast(float*)(_base2738 + 20)), + }; + _elem2738 = _record2739; + } + if (_listLen2740) deallocate ~= _listSrcPtr2740; + auto _witList2741 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.ActorLink)(_list2740); + wit.pumpkin.plugin.bedrock_packets.common.CAddActor _record2742 = { + targetActorId: cast(long)(*(cast(ulong*)(arg0 + 40))), + targetRuntimeId: cast(long)(*(cast(ulong*)(arg0 + 48))), + actorType: _list2721, + position: _tuple2722, + velocity: _tuple2723, + rotation: _tuple2724, + yHeadRotation: *(cast(float*)(arg0 + (120+2*size_t.sizeof))), + yBodyRotation: *(cast(float*)(arg0 + (124+2*size_t.sizeof))), + attributesList: _witList2730, + actorData: _list2732, + syncedProperties: _record2737, + actorLinks: _witList2741, + }; + auto _payload3459 = _record2742; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cAddActor(_payload3459); + break; + } + case _Tag3458.cAddItemActor: { + auto _len2744 = *(cast(size_t*)(arg0 + (72+1*size_t.sizeof))); + auto _ptr2744 = _len2744 ? cast(char*)(*(cast(void**)(arg0 + 72))) : null; + if (_len2744) deallocate ~= cast()_ptr2744; + auto _list2745 = WitString(_ptr2744[0.._len2744]); + auto _listSrcPtr2749 = *(cast(void**)(arg0 + (72+2*size_t.sizeof))); + auto _listLen2749 = *(cast(size_t*)(arg0 + (72+3*size_t.sizeof))); + auto _list2749 = _listLen2749 ? wit.common.mallocSlice!(WitString)(_listLen2749) : []; + assert(!_listLen2749 || _list2749.ptr); + if (_listLen2749) deallocate ~= cast(void*)_list2749.ptr; + foreach (_elem2746_idx, ref _elem2746; _list2749) { + const auto _base2746 = _listSrcPtr2749 + _elem2746_idx * (2*size_t.sizeof); + auto _len2747 = *(cast(size_t*)(_base2746 + size_t.sizeof)); + auto _ptr2747 = _len2747 ? cast(char*)(*(cast(void**)(_base2746 + 0))) : null; + if (_len2747) deallocate ~= cast()_ptr2747; + auto _list2748 = WitString(_ptr2747[0.._len2747]); + _elem2746 = _list2748; + } + if (_listLen2749) deallocate ~= _listSrcPtr2749; + auto _witList2750 = WitList!(WitString)(_list2749); + auto _listSrcPtr2754 = *(cast(void**)(arg0 + (72+4*size_t.sizeof))); + auto _listLen2754 = *(cast(size_t*)(arg0 + (72+5*size_t.sizeof))); + auto _list2754 = _listLen2754 ? wit.common.mallocSlice!(WitString)(_listLen2754) : []; + assert(!_listLen2754 || _list2754.ptr); + if (_listLen2754) deallocate ~= cast(void*)_list2754.ptr; + foreach (_elem2751_idx, ref _elem2751; _list2754) { + const auto _base2751 = _listSrcPtr2754 + _elem2751_idx * (2*size_t.sizeof); + auto _len2752 = *(cast(size_t*)(_base2751 + size_t.sizeof)); + auto _ptr2752 = _len2752 ? cast(char*)(*(cast(void**)(_base2751 + 0))) : null; + if (_len2752) deallocate ~= cast()_ptr2752; + auto _list2753 = WitString(_ptr2752[0.._len2752]); + _elem2751 = _list2753; + } + if (_listLen2754) deallocate ~= _listSrcPtr2754; + auto _witList2755 = WitList!(WitString)(_list2754); + Option!(int) _option2758 = void; + bool _isSome2758 = (cast(uint)(*(cast(ubyte*)(arg0 + (80+6*size_t.sizeof))))) != 0; + if (_isSome2758) { + + _option2758 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + (84+6*size_t.sizeof))))); + } else { + _option2758 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.ItemStackWrapper _record2759 = { + id: cast(int)(*(cast(uint*)(arg0 + 56))), + stackSize: cast(int)(*(cast(uint*)(arg0 + 60))), + auxValue: cast(int)(*(cast(uint*)(arg0 + 64))), + blockRuntimeId: cast(int)(*(cast(uint*)(arg0 + 68))), + nbtData: _list2745, + placeOnBlocks: _witList2750, + destroyBlocks: _witList2755, + shieldBlockingTick: cast(long)(*(cast(ulong*)(arg0 + (72+6*size_t.sizeof)))), + netId: _option2758, + }; + auto _tuple2760 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + (88+6*size_t.sizeof))), + *(cast(double*)(arg0 + (96+6*size_t.sizeof))), + *(cast(double*)(arg0 + (104+6*size_t.sizeof))), + ); + auto _tuple2761 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + (112+6*size_t.sizeof))), + *(cast(double*)(arg0 + (120+6*size_t.sizeof))), + *(cast(double*)(arg0 + (128+6*size_t.sizeof))), + ); + auto _len2762 = *(cast(size_t*)(arg0 + (136+7*size_t.sizeof))); + auto _ptr2762 = _len2762 ? cast(char*)(*(cast(void**)(arg0 + (136+6*size_t.sizeof)))) : null; + if (_len2762) deallocate ~= cast()_ptr2762; + auto _list2763 = WitString(_ptr2762[0.._len2762]); + wit.pumpkin.plugin.bedrock_packets.common.CAddItemActor _record2764 = { + targetActorId: cast(long)(*(cast(ulong*)(arg0 + 40))), + targetRuntimeId: cast(long)(*(cast(ulong*)(arg0 + 48))), + item: _record2759, + position: _tuple2760, + velocity: _tuple2761, + entityData: _list2763, + isFromFishing: (cast(uint)(*(cast(ubyte*)(arg0 + (136+8*size_t.sizeof))))) != 0, + }; + auto _payload3460 = _record2764; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cAddItemActor(_payload3460); + break; + } + case _Tag3458.cAddPlayer: { + wit.pumpkin.plugin.uuid.common.Uuid _record2766 = { + high: *(cast(ulong*)(arg0 + 40)), + low: *(cast(ulong*)(arg0 + 48)), + }; + auto _len2767 = *(cast(size_t*)(arg0 + (56+1*size_t.sizeof))); + auto _ptr2767 = _len2767 ? cast(char*)(*(cast(void**)(arg0 + 56))) : null; + if (_len2767) deallocate ~= cast()_ptr2767; + auto _list2768 = WitString(_ptr2767[0.._len2767]); + auto _len2769 = *(cast(size_t*)(arg0 + (64+3*size_t.sizeof))); + auto _ptr2769 = _len2769 ? cast(char*)(*(cast(void**)(arg0 + (64+2*size_t.sizeof)))) : null; + if (_len2769) deallocate ~= cast()_ptr2769; + auto _list2770 = WitString(_ptr2769[0.._len2769]); + auto _tuple2771 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + (64+4*size_t.sizeof))), + *(cast(double*)(arg0 + (72+4*size_t.sizeof))), + *(cast(double*)(arg0 + (80+4*size_t.sizeof))), + ); + auto _tuple2772 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + (88+4*size_t.sizeof))), + *(cast(double*)(arg0 + (96+4*size_t.sizeof))), + *(cast(double*)(arg0 + (104+4*size_t.sizeof))), + ); + auto _tuple2773 = Tuple!(double, double)( + *(cast(double*)(arg0 + (112+4*size_t.sizeof))), + *(cast(double*)(arg0 + (120+4*size_t.sizeof))), + ); + auto _len2774 = *(cast(size_t*)(arg0 + (144+6*size_t.sizeof))); + auto _ptr2774 = _len2774 ? cast(ubyte*)(*(cast(void**)(arg0 + (144+5*size_t.sizeof)))) : null; + if (_len2774) deallocate ~= cast()_ptr2774; + auto _list2775 = WitList!(ubyte)(_ptr2774[0.._len2774]); + Option!(int) _option2778 = void; + bool _isSome2778 = (cast(uint)(*(cast(ubyte*)(arg0 + (144+7*size_t.sizeof))))) != 0; + if (_isSome2778) { + + _option2778 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + (148+7*size_t.sizeof))))); + } else { + _option2778 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.NetworkItemStackDescriptor _record2779 = { + id: cast(int)(*(cast(uint*)(arg0 + (128+5*size_t.sizeof)))), + stackSize: cast(int)(*(cast(uint*)(arg0 + (132+5*size_t.sizeof)))), + auxValue: cast(int)(*(cast(uint*)(arg0 + (136+5*size_t.sizeof)))), + blockRuntimeId: cast(int)(*(cast(uint*)(arg0 + (140+5*size_t.sizeof)))), + extraData: _list2775, + netId: _option2778, + }; + auto _len2780 = *(cast(size_t*)(arg0 + (152+9*size_t.sizeof))); + auto _ptr2780 = _len2780 ? cast(char*)(*(cast(void**)(arg0 + (152+8*size_t.sizeof)))) : null; + if (_len2780) deallocate ~= cast()_ptr2780; + auto _list2781 = WitString(_ptr2780[0.._len2780]); + auto _len2782 = *(cast(size_t*)(arg0 + (152+11*size_t.sizeof))); + auto _ptr2782 = _len2782 ? cast(Tuple!(int, int)*)(*(cast(void**)(arg0 + (152+10*size_t.sizeof)))) : null; + if (_len2782) deallocate ~= cast()_ptr2782; + auto _list2783 = WitList!(Tuple!(int, int))(_ptr2782[0.._len2782]); + auto _len2784 = *(cast(size_t*)(arg0 + (152+13*size_t.sizeof))); + auto _ptr2784 = _len2784 ? cast(Tuple!(int, float)*)(*(cast(void**)(arg0 + (152+12*size_t.sizeof)))) : null; + if (_len2784) deallocate ~= cast()_ptr2784; + auto _list2785 = WitList!(Tuple!(int, float))(_ptr2784[0.._len2784]); + wit.pumpkin.plugin.bedrock_packets.common.PropertySyncData _record2786 = { + intEntriesList: _list2783, + floatEntriesList: _list2785, + }; + auto _len2787 = *(cast(size_t*)(arg0 + (160+16*size_t.sizeof))); + auto _ptr2787 = _len2787 ? cast(wit.pumpkin.plugin.bedrock_packets.common.SerializedAbilitiesDataSerializedLayer*)(*(cast(void**)(arg0 + (160+15*size_t.sizeof)))) : null; + if (_len2787) deallocate ~= cast()_ptr2787; + auto _list2788 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.SerializedAbilitiesDataSerializedLayer)(_ptr2787[0.._len2787]); + wit.pumpkin.plugin.bedrock_packets.common.SerializedAbilitiesData _record2789 = { + targetPlayerRawId: cast(long)(*(cast(ulong*)(arg0 + (152+14*size_t.sizeof)))), + playerPermissions: cast(wit.pumpkin.plugin.bedrock_packets.common.PlayerPermissionLevel)(cast(uint)(*(cast(ubyte*)(arg0 + (160+14*size_t.sizeof))))), + commandPermissions: cast(wit.pumpkin.plugin.bedrock_packets.common.CommandPermissionLevel)(cast(uint)(*(cast(ubyte*)(arg0 + (161+14*size_t.sizeof))))), + layers: _list2788, + }; + auto _listSrcPtr2792 = *(cast(void**)(arg0 + (168+16*size_t.sizeof))); + auto _listLen2792 = *(cast(size_t*)(arg0 + (168+17*size_t.sizeof))); + auto _list2792 = _listLen2792 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.ActorLink)(_listLen2792) : []; + assert(!_listLen2792 || _list2792.ptr); + if (_listLen2792) deallocate ~= cast(void*)_list2792.ptr; + foreach (_elem2790_idx, ref _elem2790; _list2792) { + const auto _base2790 = _listSrcPtr2792 + _elem2790_idx * 24; + wit.pumpkin.plugin.bedrock_packets.common.ActorLink _record2791 = { + riddenUniqueId: cast(long)(*(cast(ulong*)(_base2790 + 0))), + riderUniqueId: cast(long)(*(cast(ulong*)(_base2790 + 8))), + linkType: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base2790 + 16)))), + immediate: (cast(uint)(*(cast(ubyte*)(_base2790 + 17)))) != 0, + riderInitiated: (cast(uint)(*(cast(ubyte*)(_base2790 + 18)))) != 0, + vehicleAngularVelocity: *(cast(float*)(_base2790 + 20)), + }; + _elem2790 = _record2791; + } + if (_listLen2792) deallocate ~= _listSrcPtr2792; + auto _witList2793 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.ActorLink)(_list2792); + auto _len2794 = *(cast(size_t*)(arg0 + (168+19*size_t.sizeof))); + auto _ptr2794 = _len2794 ? cast(char*)(*(cast(void**)(arg0 + (168+18*size_t.sizeof)))) : null; + if (_len2794) deallocate ~= cast()_ptr2794; + auto _list2795 = WitString(_ptr2794[0.._len2794]); + wit.pumpkin.plugin.bedrock_packets.common.CAddPlayer _record2796 = { + uuid: _record2766, + playerName: _list2768, + targetRuntimeId: cast(long)(*(cast(ulong*)(arg0 + (56+2*size_t.sizeof)))), + platformChatId: _list2770, + position: _tuple2771, + velocity: _tuple2772, + rotation: _tuple2773, + yHeadRotation: *(cast(float*)(arg0 + (128+4*size_t.sizeof))), + carriedItem: _record2779, + playerGameType: cast(wit.pumpkin.plugin.bedrock_packets.common.GameType)(cast(uint)(*(cast(ubyte*)(arg0 + (152+7*size_t.sizeof))))), + entityData: _list2781, + syncedProperties: _record2786, + abilitiesData: _record2789, + actorLinks: _witList2793, + deviceId: _list2795, + buildPlatform: cast(wit.pumpkin.plugin.bedrock_packets.common.BuildPlatform)(cast(uint)(*(cast(ubyte*)(arg0 + (168+20*size_t.sizeof))))), + }; + auto _payload3461 = _record2796; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cAddPlayer(_payload3461); + break; + } + case _Tag3458.cAvailableCommands: { + auto _listSrcPtr2801 = *(cast(void**)(arg0 + 40)); + auto _listLen2801 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _list2801 = _listLen2801 ? wit.common.mallocSlice!(WitString)(_listLen2801) : []; + assert(!_listLen2801 || _list2801.ptr); + if (_listLen2801) deallocate ~= cast(void*)_list2801.ptr; + foreach (_elem2798_idx, ref _elem2798; _list2801) { + const auto _base2798 = _listSrcPtr2801 + _elem2798_idx * (2*size_t.sizeof); + auto _len2799 = *(cast(size_t*)(_base2798 + size_t.sizeof)); + auto _ptr2799 = _len2799 ? cast(char*)(*(cast(void**)(_base2798 + 0))) : null; + if (_len2799) deallocate ~= cast()_ptr2799; + auto _list2800 = WitString(_ptr2799[0.._len2799]); + _elem2798 = _list2800; + } + if (_listLen2801) deallocate ~= _listSrcPtr2801; + auto _witList2802 = WitList!(WitString)(_list2801); + auto _listSrcPtr2806 = *(cast(void**)(arg0 + (40+2*size_t.sizeof))); + auto _listLen2806 = *(cast(size_t*)(arg0 + (40+3*size_t.sizeof))); + auto _list2806 = _listLen2806 ? wit.common.mallocSlice!(WitString)(_listLen2806) : []; + assert(!_listLen2806 || _list2806.ptr); + if (_listLen2806) deallocate ~= cast(void*)_list2806.ptr; + foreach (_elem2803_idx, ref _elem2803; _list2806) { + const auto _base2803 = _listSrcPtr2806 + _elem2803_idx * (2*size_t.sizeof); + auto _len2804 = *(cast(size_t*)(_base2803 + size_t.sizeof)); + auto _ptr2804 = _len2804 ? cast(char*)(*(cast(void**)(_base2803 + 0))) : null; + if (_len2804) deallocate ~= cast()_ptr2804; + auto _list2805 = WitString(_ptr2804[0.._len2804]); + _elem2803 = _list2805; + } + if (_listLen2806) deallocate ~= _listSrcPtr2806; + auto _witList2807 = WitList!(WitString)(_list2806); + auto _listSrcPtr2811 = *(cast(void**)(arg0 + (40+4*size_t.sizeof))); + auto _listLen2811 = *(cast(size_t*)(arg0 + (40+5*size_t.sizeof))); + auto _list2811 = _listLen2811 ? wit.common.mallocSlice!(WitString)(_listLen2811) : []; + assert(!_listLen2811 || _list2811.ptr); + if (_listLen2811) deallocate ~= cast(void*)_list2811.ptr; + foreach (_elem2808_idx, ref _elem2808; _list2811) { + const auto _base2808 = _listSrcPtr2811 + _elem2808_idx * (2*size_t.sizeof); + auto _len2809 = *(cast(size_t*)(_base2808 + size_t.sizeof)); + auto _ptr2809 = _len2809 ? cast(char*)(*(cast(void**)(_base2808 + 0))) : null; + if (_len2809) deallocate ~= cast()_ptr2809; + auto _list2810 = WitString(_ptr2809[0.._len2809]); + _elem2808 = _list2810; + } + if (_listLen2811) deallocate ~= _listSrcPtr2811; + auto _witList2812 = WitList!(WitString)(_list2811); + auto _listSrcPtr2819 = *(cast(void**)(arg0 + (40+6*size_t.sizeof))); + auto _listLen2819 = *(cast(size_t*)(arg0 + (40+7*size_t.sizeof))); + auto _list2819 = _listLen2819 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.EnumData)(_listLen2819) : []; + assert(!_listLen2819 || _list2819.ptr); + if (_listLen2819) deallocate ~= cast(void*)_list2819.ptr; + foreach (_elem2813_idx, ref _elem2813; _list2819) { + const auto _base2813 = _listSrcPtr2819 + _elem2813_idx * (4*size_t.sizeof); + auto _len2814 = *(cast(size_t*)(_base2813 + size_t.sizeof)); + auto _ptr2814 = _len2814 ? cast(char*)(*(cast(void**)(_base2813 + 0))) : null; + if (_len2814) deallocate ~= cast()_ptr2814; + auto _list2815 = WitString(_ptr2814[0.._len2814]); + auto _len2816 = *(cast(size_t*)(_base2813 + (3*size_t.sizeof))); + auto _ptr2816 = _len2816 ? cast(int*)(*(cast(void**)(_base2813 + (2*size_t.sizeof)))) : null; + if (_len2816) deallocate ~= cast()_ptr2816; + auto _list2817 = WitList!(int)(_ptr2816[0.._len2816]); + wit.pumpkin.plugin.bedrock_packets.common.EnumData _record2818 = { + name: _list2815, + values: _list2817, + }; + _elem2813 = _record2818; + } + if (_listLen2819) deallocate ~= _listSrcPtr2819; + auto _witList2820 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.EnumData)(_list2819); + auto _listSrcPtr2827 = *(cast(void**)(arg0 + (40+8*size_t.sizeof))); + auto _listLen2827 = *(cast(size_t*)(arg0 + (40+9*size_t.sizeof))); + auto _list2827 = _listLen2827 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.ChainedSubcommandData)(_listLen2827) : []; + assert(!_listLen2827 || _list2827.ptr); + if (_listLen2827) deallocate ~= cast(void*)_list2827.ptr; + foreach (_elem2821_idx, ref _elem2821; _list2827) { + const auto _base2821 = _listSrcPtr2827 + _elem2821_idx * (4*size_t.sizeof); + auto _len2822 = *(cast(size_t*)(_base2821 + size_t.sizeof)); + auto _ptr2822 = _len2822 ? cast(char*)(*(cast(void**)(_base2821 + 0))) : null; + if (_len2822) deallocate ~= cast()_ptr2822; + auto _list2823 = WitString(_ptr2822[0.._len2822]); + auto _len2824 = *(cast(size_t*)(_base2821 + (3*size_t.sizeof))); + auto _ptr2824 = _len2824 ? cast(wit.pumpkin.plugin.bedrock_packets.common.ChainedSubcommandRelationship*)(*(cast(void**)(_base2821 + (2*size_t.sizeof)))) : null; + if (_len2824) deallocate ~= cast()_ptr2824; + auto _list2825 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.ChainedSubcommandRelationship)(_ptr2824[0.._len2824]); + wit.pumpkin.plugin.bedrock_packets.common.ChainedSubcommandData _record2826 = { + name: _list2823, + subcommandValues: _list2825, + }; + _elem2821 = _record2826; + } + if (_listLen2827) deallocate ~= _listSrcPtr2827; + auto _witList2828 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.ChainedSubcommandData)(_list2827); + auto _listSrcPtr2847 = *(cast(void**)(arg0 + (40+10*size_t.sizeof))); + auto _listLen2847 = *(cast(size_t*)(arg0 + (40+11*size_t.sizeof))); + auto _list2847 = _listLen2847 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.CommandData)(_listLen2847) : []; + assert(!_listLen2847 || _list2847.ptr); + if (_listLen2847) deallocate ~= cast(void*)_list2847.ptr; + foreach (_elem2829_idx, ref _elem2829; _list2847) { + const auto _base2829 = _listSrcPtr2847 + _elem2829_idx * (8+9*size_t.sizeof); + auto _len2830 = *(cast(size_t*)(_base2829 + size_t.sizeof)); + auto _ptr2830 = _len2830 ? cast(char*)(*(cast(void**)(_base2829 + 0))) : null; + if (_len2830) deallocate ~= cast()_ptr2830; + auto _list2831 = WitString(_ptr2830[0.._len2830]); + auto _len2832 = *(cast(size_t*)(_base2829 + (3*size_t.sizeof))); + auto _ptr2832 = _len2832 ? cast(char*)(*(cast(void**)(_base2829 + (2*size_t.sizeof)))) : null; + if (_len2832) deallocate ~= cast()_ptr2832; + auto _list2833 = WitString(_ptr2832[0.._len2832]); + auto _len2834 = *(cast(size_t*)(_base2829 + (8+6*size_t.sizeof))); + auto _ptr2834 = _len2834 ? cast(int*)(*(cast(void**)(_base2829 + (8+5*size_t.sizeof)))) : null; + if (_len2834) deallocate ~= cast()_ptr2834; + auto _list2835 = WitList!(int)(_ptr2834[0.._len2834]); + auto _listSrcPtr2844 = *(cast(void**)(_base2829 + (8+7*size_t.sizeof))); + auto _listLen2844 = *(cast(size_t*)(_base2829 + (8+8*size_t.sizeof))); + auto _list2844 = _listLen2844 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.OverloadData)(_listLen2844) : []; + assert(!_listLen2844 || _list2844.ptr); + if (_listLen2844) deallocate ~= cast(void*)_list2844.ptr; + foreach (_elem2836_idx, ref _elem2836; _list2844) { + const auto _base2836 = _listSrcPtr2844 + _elem2836_idx * (3*size_t.sizeof); + auto _listSrcPtr2841 = *(cast(void**)(_base2836 + size_t.sizeof)); + auto _listLen2841 = *(cast(size_t*)(_base2836 + (2*size_t.sizeof))); + auto _list2841 = _listLen2841 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.ParamData)(_listLen2841) : []; + assert(!_listLen2841 || _list2841.ptr); + if (_listLen2841) deallocate ~= cast(void*)_list2841.ptr; + foreach (_elem2837_idx, ref _elem2837; _list2841) { + const auto _base2837 = _listSrcPtr2841 + _elem2837_idx * (8+2*size_t.sizeof); + auto _len2838 = *(cast(size_t*)(_base2837 + size_t.sizeof)); + auto _ptr2838 = _len2838 ? cast(char*)(*(cast(void**)(_base2837 + 0))) : null; + if (_len2838) deallocate ~= cast()_ptr2838; + auto _list2839 = WitString(_ptr2838[0.._len2838]); + wit.pumpkin.plugin.bedrock_packets.common.ParamData _record2840 = { + name: _list2839, + parseSymbol: cast(int)(*(cast(uint*)(_base2837 + (2*size_t.sizeof)))), + isOptional: (cast(uint)(*(cast(ubyte*)(_base2837 + (4+2*size_t.sizeof))))) != 0, + options: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base2837 + (5+2*size_t.sizeof))))), + }; + _elem2837 = _record2840; + } + if (_listLen2841) deallocate ~= _listSrcPtr2841; + auto _witList2842 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.ParamData)(_list2841); + wit.pumpkin.plugin.bedrock_packets.common.OverloadData _record2843 = { + isChaining: (cast(uint)(*(cast(ubyte*)(_base2836 + 0)))) != 0, + parameterData: _witList2842, + }; + _elem2836 = _record2843; + } + if (_listLen2844) deallocate ~= _listSrcPtr2844; + auto _witList2845 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.OverloadData)(_list2844); + wit.pumpkin.plugin.bedrock_packets.common.CommandData _record2846 = { + name: _list2831, + description: _list2833, + flags: cast(int)(*(cast(uint*)(_base2829 + (4*size_t.sizeof)))), + permissionLevel: cast(wit.pumpkin.plugin.bedrock_packets.common.CommandPermissionLevel)(cast(uint)(*(cast(ubyte*)(_base2829 + (4+4*size_t.sizeof))))), + aliasEnum: cast(int)(*(cast(uint*)(_base2829 + (8+4*size_t.sizeof)))), + commandDataChainedSubcommandIndexes: _list2835, + overloads: _witList2845, + }; + _elem2829 = _record2846; + } + if (_listLen2847) deallocate ~= _listSrcPtr2847; + auto _witList2848 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.CommandData)(_list2847); + auto _listSrcPtr2858 = *(cast(void**)(arg0 + (40+12*size_t.sizeof))); + auto _listLen2858 = *(cast(size_t*)(arg0 + (40+13*size_t.sizeof))); + auto _list2858 = _listLen2858 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.SoftEnumData)(_listLen2858) : []; + assert(!_listLen2858 || _list2858.ptr); + if (_listLen2858) deallocate ~= cast(void*)_list2858.ptr; + foreach (_elem2849_idx, ref _elem2849; _list2858) { + const auto _base2849 = _listSrcPtr2858 + _elem2849_idx * (4*size_t.sizeof); + auto _len2850 = *(cast(size_t*)(_base2849 + size_t.sizeof)); + auto _ptr2850 = _len2850 ? cast(char*)(*(cast(void**)(_base2849 + 0))) : null; + if (_len2850) deallocate ~= cast()_ptr2850; + auto _list2851 = WitString(_ptr2850[0.._len2850]); + auto _listSrcPtr2855 = *(cast(void**)(_base2849 + (2*size_t.sizeof))); + auto _listLen2855 = *(cast(size_t*)(_base2849 + (3*size_t.sizeof))); + auto _list2855 = _listLen2855 ? wit.common.mallocSlice!(WitString)(_listLen2855) : []; + assert(!_listLen2855 || _list2855.ptr); + if (_listLen2855) deallocate ~= cast(void*)_list2855.ptr; + foreach (_elem2852_idx, ref _elem2852; _list2855) { + const auto _base2852 = _listSrcPtr2855 + _elem2852_idx * (2*size_t.sizeof); + auto _len2853 = *(cast(size_t*)(_base2852 + size_t.sizeof)); + auto _ptr2853 = _len2853 ? cast(char*)(*(cast(void**)(_base2852 + 0))) : null; + if (_len2853) deallocate ~= cast()_ptr2853; + auto _list2854 = WitString(_ptr2853[0.._len2853]); + _elem2852 = _list2854; + } + if (_listLen2855) deallocate ~= _listSrcPtr2855; + auto _witList2856 = WitList!(WitString)(_list2855); + wit.pumpkin.plugin.bedrock_packets.common.SoftEnumData _record2857 = { + enumName: _list2851, + enumOptions: _witList2856, + }; + _elem2849 = _record2857; + } + if (_listLen2858) deallocate ~= _listSrcPtr2858; + auto _witList2859 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.SoftEnumData)(_list2858); + auto _listSrcPtr2864 = *(cast(void**)(arg0 + (40+14*size_t.sizeof))); + auto _listLen2864 = *(cast(size_t*)(arg0 + (40+15*size_t.sizeof))); + auto _list2864 = _listLen2864 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.ConstrainedValueData)(_listLen2864) : []; + assert(!_listLen2864 || _list2864.ptr); + if (_listLen2864) deallocate ~= cast(void*)_list2864.ptr; + foreach (_elem2860_idx, ref _elem2860; _list2864) { + const auto _base2860 = _listSrcPtr2864 + _elem2860_idx * (8+2*size_t.sizeof); + auto _len2861 = *(cast(size_t*)(_base2860 + (8+1*size_t.sizeof))); + auto _ptr2861 = _len2861 ? cast(ubyte*)(*(cast(void**)(_base2860 + 8))) : null; + if (_len2861) deallocate ~= cast()_ptr2861; + auto _list2862 = WitList!(ubyte)(_ptr2861[0.._len2861]); + wit.pumpkin.plugin.bedrock_packets.common.ConstrainedValueData _record2863 = { + enumValueSymbol: cast(int)(*(cast(uint*)(_base2860 + 0))), + enumSymbol: cast(int)(*(cast(uint*)(_base2860 + 4))), + constraintIndices: _list2862, + }; + _elem2860 = _record2863; + } + if (_listLen2864) deallocate ~= _listSrcPtr2864; + auto _witList2865 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.ConstrainedValueData)(_list2864); + wit.pumpkin.plugin.bedrock_packets.common.CAvailableCommands _record2866 = { + enumValues: _witList2802, + chainedSubcommandValues: _witList2807, + postFixes: _witList2812, + enumData: _witList2820, + chainedSubcommandData: _witList2828, + commands: _witList2848, + softEnums: _witList2859, + constraints: _witList2865, + }; + auto _payload3462 = _record2866; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cAvailableCommands(_payload3462); + break; + } + case _Tag3458.cBiomeDefinitionList: { + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cBiomeDefinitionList(); + break; + } + case _Tag3458.cBlockActorData: { + auto _tuple2869 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 40))), + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + ); + auto _len2870 = *(cast(size_t*)(arg0 + (48+2*size_t.sizeof))); + auto _ptr2870 = _len2870 ? cast(char*)(*(cast(void**)(arg0 + (48+1*size_t.sizeof)))) : null; + if (_len2870) deallocate ~= cast()_ptr2870; + auto _list2871 = WitString(_ptr2870[0.._len2870]); + wit.pumpkin.plugin.bedrock_packets.common.CBlockActorData _record2872 = { + blockPosition: _tuple2869, + actorDataTags: _list2871, + }; + auto _payload3464 = _record2872; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cBlockActorData(_payload3464); + break; + } + case _Tag3458.cBlockEvent: { + auto _tuple2874 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 40))), + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + ); + wit.pumpkin.plugin.bedrock_packets.common.CBlockEvent _record2875 = { + blockPosition: _tuple2874, + eventType: cast(int)(*(cast(uint*)(arg0 + 52))), + eventValue: cast(int)(*(cast(uint*)(arg0 + 56))), + }; + auto _payload3465 = _record2875; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cBlockEvent(_payload3465); + break; + } + case _Tag3458.cBossEvent: { + auto _len2877 = *(cast(size_t*)(arg0 + (56+2*size_t.sizeof))); + auto _ptr2877 = _len2877 ? cast(char*)(*(cast(void**)(arg0 + (56+1*size_t.sizeof)))) : null; + if (_len2877) deallocate ~= cast()_ptr2877; + auto _list2878 = WitString(_ptr2877[0.._len2877]); + auto _len2879 = *(cast(size_t*)(arg0 + (56+4*size_t.sizeof))); + auto _ptr2879 = _len2879 ? cast(char*)(*(cast(void**)(arg0 + (56+3*size_t.sizeof)))) : null; + if (_len2879) deallocate ~= cast()_ptr2879; + auto _list2880 = WitString(_ptr2879[0.._len2879]); + wit.pumpkin.plugin.bedrock_packets.common.CBossEvent _record2881 = { + bossEntityId: cast(long)(*(cast(ulong*)(arg0 + 40))), + playerEntityId: cast(long)(*(cast(ulong*)(arg0 + 48))), + eventType: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 56)))), + title: _list2878, + filteredTitle: _list2880, + healthPercentage: *(cast(float*)(arg0 + (56+5*size_t.sizeof))), + color: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (60+5*size_t.sizeof))))), + overlay: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (61+5*size_t.sizeof))))), + }; + auto _payload3466 = _record2881; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cBossEvent(_payload3466); + break; + } + case _Tag3458.cChangeDimension: { + auto _tuple2883 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 48)), + *(cast(double*)(arg0 + 56)), + *(cast(double*)(arg0 + 64)), + ); + Option!(int) _option2886 = void; + bool _isSome2886 = (cast(uint)(*(cast(ubyte*)(arg0 + 76)))) != 0; + if (_isSome2886) { + + _option2886 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + 80)))); + } else { + _option2886 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.CChangeDimension _record2887 = { + dimensionId: cast(int)(*(cast(uint*)(arg0 + 40))), + position: _tuple2883, + respawn: (cast(uint)(*(cast(ubyte*)(arg0 + 72)))) != 0, + loadingScreenId: _option2886, + }; + auto _payload3467 = _record2887; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cChangeDimension(_payload3467); + break; + } + case _Tag3458.cChunkRadiusUpdated: { + wit.pumpkin.plugin.bedrock_packets.common.CChunkRadiusUpdated _record2889 = { + chunkRadius: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload3468 = _record2889; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cChunkRadiusUpdated(_payload3468); + break; + } + case _Tag3458.cClientCacheMissResponse: { + auto _listSrcPtr2895 = *(cast(void**)(arg0 + 40)); + auto _listLen2895 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _list2895 = _listLen2895 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.MissingBlobData)(_listLen2895) : []; + assert(!_listLen2895 || _list2895.ptr); + if (_listLen2895) deallocate ~= cast(void*)_list2895.ptr; + foreach (_elem2891_idx, ref _elem2891; _list2895) { + const auto _base2891 = _listSrcPtr2895 + _elem2891_idx * (8+2*size_t.sizeof); + auto _len2892 = *(cast(size_t*)(_base2891 + (8+1*size_t.sizeof))); + auto _ptr2892 = _len2892 ? cast(ubyte*)(*(cast(void**)(_base2891 + 8))) : null; + if (_len2892) deallocate ~= cast()_ptr2892; + auto _list2893 = WitList!(ubyte)(_ptr2892[0.._len2892]); + wit.pumpkin.plugin.bedrock_packets.common.MissingBlobData _record2894 = { + blobId: cast(long)(*(cast(ulong*)(_base2891 + 0))), + blobData: _list2893, + }; + _elem2891 = _record2894; + } + if (_listLen2895) deallocate ~= _listSrcPtr2895; + auto _witList2896 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.MissingBlobData)(_list2895); + wit.pumpkin.plugin.bedrock_packets.common.CClientCacheMissResponse _record2897 = { + missingBlobs: _witList2896, + }; + auto _payload3469 = _record2897; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cClientCacheMissResponse(_payload3469); + break; + } + case _Tag3458.cContainerOpen: { + auto _tuple2899 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + cast(int)(*(cast(uint*)(arg0 + 52))), + ); + wit.pumpkin.plugin.bedrock_packets.common.CContainerOpen _record2900 = { + containerId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 40)))), + containerType: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 41)))), + position: _tuple2899, + targetEntityId: cast(long)(*(cast(ulong*)(arg0 + 56))), + }; + auto _payload3470 = _record2900; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cContainerOpen(_payload3470); + break; + } + case _Tag3458.cCorrectPlayerMovePrediction: { + auto _tuple2902 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 48)), + *(cast(double*)(arg0 + 56)), + *(cast(double*)(arg0 + 64)), + ); + auto _tuple2903 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 72)), + *(cast(double*)(arg0 + 80)), + *(cast(double*)(arg0 + 88)), + ); + auto _tuple2904 = Tuple!(double, double)( + *(cast(double*)(arg0 + 96)), + *(cast(double*)(arg0 + 104)), + ); + Option!(float) _option2907 = void; + bool _isSome2907 = (cast(uint)(*(cast(ubyte*)(arg0 + 112)))) != 0; + if (_isSome2907) { + + _option2907 = Option!(float).makeSome(*(cast(float*)(arg0 + 116))); + } else { + _option2907 = Option!(float).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.CCorrectPlayerMovePrediction _record2908 = { + predictionType: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 40)))), + pos: _tuple2902, + posDelta: _tuple2903, + rotation: _tuple2904, + vehicleAngularVelocity: _option2907, + onGround: (cast(uint)(*(cast(ubyte*)(arg0 + 120)))) != 0, + tick: cast(long)(*(cast(ulong*)(arg0 + 128))), + }; + auto _payload3471 = _record2908; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cCorrectPlayerMovePrediction(_payload3471); + break; + } + case _Tag3458.cCraftingData: { + auto _listSrcPtr2974 = *(cast(void**)(arg0 + 40)); + auto _listLen2974 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _list2974 = _listLen2974 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.BedrockRecipe)(_listLen2974) : []; + assert(!_listLen2974 || _list2974.ptr); + if (_listLen2974) deallocate ~= cast(void*)_list2974.ptr; + foreach (_elem2910_idx, ref _elem2910; _list2974) { + const auto _base2910 = _listSrcPtr2974 + _elem2910_idx * (48+8*size_t.sizeof); + wit.pumpkin.plugin.bedrock_packets.common.BedrockRecipe _variant2971 = void; + auto _tag2971 = cast(uint)(*(cast(ubyte*)(_base2910 + 0))); + alias _Tag2971 = wit.pumpkin.plugin.bedrock_packets.common.BedrockRecipe.Tag; + final switch (cast(wit.pumpkin.plugin.bedrock_packets.common.BedrockRecipe.Tag)_tag2971) { + case _Tag2971.shapeless: { + auto _len2912 = *(cast(size_t*)(_base2910 + (8+1*size_t.sizeof))); + auto _ptr2912 = _len2912 ? cast(char*)(*(cast(void**)(_base2910 + 8))) : null; + if (_len2912) deallocate ~= cast()_ptr2912; + auto _list2913 = WitString(_ptr2912[0.._len2912]); + auto _listSrcPtr2918 = *(cast(void**)(_base2910 + (8+2*size_t.sizeof))); + auto _listLen2918 = *(cast(size_t*)(_base2910 + (8+3*size_t.sizeof))); + auto _list2918 = _listLen2918 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.ItemDescriptorCount)(_listLen2918) : []; + assert(!_listLen2918 || _list2918.ptr); + if (_listLen2918) deallocate ~= cast(void*)_list2918.ptr; + foreach (_elem2914_idx, ref _elem2914; _list2918) { + const auto _base2914 = _listSrcPtr2918 + _elem2914_idx * (8+2*size_t.sizeof); + auto _len2915 = *(cast(size_t*)(_base2914 + size_t.sizeof)); + auto _ptr2915 = _len2915 ? cast(char*)(*(cast(void**)(_base2914 + 0))) : null; + if (_len2915) deallocate ~= cast()_ptr2915; + auto _list2916 = WitString(_ptr2915[0.._len2915]); + wit.pumpkin.plugin.bedrock_packets.common.ItemDescriptorCount _record2917 = { + itemIdentifier: _list2916, + metadataValue: cast(int)(*(cast(uint*)(_base2914 + (2*size_t.sizeof)))), + count: cast(int)(*(cast(uint*)(_base2914 + (4+2*size_t.sizeof)))), + }; + _elem2914 = _record2917; + } + if (_listLen2918) deallocate ~= _listSrcPtr2918; + auto _witList2919 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.ItemDescriptorCount)(_list2918); + auto _listSrcPtr2934 = *(cast(void**)(_base2910 + (8+4*size_t.sizeof))); + auto _listLen2934 = *(cast(size_t*)(_base2910 + (8+5*size_t.sizeof))); + auto _list2934 = _listLen2934 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.NetworkItemDescriptor)(_listLen2934) : []; + assert(!_listLen2934 || _list2934.ptr); + if (_listLen2934) deallocate ~= cast(void*)_list2934.ptr; + foreach (_elem2920_idx, ref _elem2920; _list2934) { + const auto _base2920 = _listSrcPtr2934 + _elem2920_idx * (24+6*size_t.sizeof); + auto _len2921 = *(cast(size_t*)(_base2920 + (16+1*size_t.sizeof))); + auto _ptr2921 = _len2921 ? cast(char*)(*(cast(void**)(_base2920 + 16))) : null; + if (_len2921) deallocate ~= cast()_ptr2921; + auto _list2922 = WitString(_ptr2921[0.._len2921]); + auto _listSrcPtr2926 = *(cast(void**)(_base2920 + (16+2*size_t.sizeof))); + auto _listLen2926 = *(cast(size_t*)(_base2920 + (16+3*size_t.sizeof))); + auto _list2926 = _listLen2926 ? wit.common.mallocSlice!(WitString)(_listLen2926) : []; + assert(!_listLen2926 || _list2926.ptr); + if (_listLen2926) deallocate ~= cast(void*)_list2926.ptr; + foreach (_elem2923_idx, ref _elem2923; _list2926) { + const auto _base2923 = _listSrcPtr2926 + _elem2923_idx * (2*size_t.sizeof); + auto _len2924 = *(cast(size_t*)(_base2923 + size_t.sizeof)); + auto _ptr2924 = _len2924 ? cast(char*)(*(cast(void**)(_base2923 + 0))) : null; + if (_len2924) deallocate ~= cast()_ptr2924; + auto _list2925 = WitString(_ptr2924[0.._len2924]); + _elem2923 = _list2925; + } + if (_listLen2926) deallocate ~= _listSrcPtr2926; + auto _witList2927 = WitList!(WitString)(_list2926); + auto _listSrcPtr2931 = *(cast(void**)(_base2920 + (16+4*size_t.sizeof))); + auto _listLen2931 = *(cast(size_t*)(_base2920 + (16+5*size_t.sizeof))); + auto _list2931 = _listLen2931 ? wit.common.mallocSlice!(WitString)(_listLen2931) : []; + assert(!_listLen2931 || _list2931.ptr); + if (_listLen2931) deallocate ~= cast(void*)_list2931.ptr; + foreach (_elem2928_idx, ref _elem2928; _list2931) { + const auto _base2928 = _listSrcPtr2931 + _elem2928_idx * (2*size_t.sizeof); + auto _len2929 = *(cast(size_t*)(_base2928 + size_t.sizeof)); + auto _ptr2929 = _len2929 ? cast(char*)(*(cast(void**)(_base2928 + 0))) : null; + if (_len2929) deallocate ~= cast()_ptr2929; + auto _list2930 = WitString(_ptr2929[0.._len2929]); + _elem2928 = _list2930; + } + if (_listLen2931) deallocate ~= _listSrcPtr2931; + auto _witList2932 = WitList!(WitString)(_list2931); + wit.pumpkin.plugin.bedrock_packets.common.NetworkItemDescriptor _record2933 = { + id: cast(int)(*(cast(uint*)(_base2920 + 0))), + stackSize: cast(int)(*(cast(uint*)(_base2920 + 4))), + auxValue: cast(int)(*(cast(uint*)(_base2920 + 8))), + blockRuntimeId: cast(int)(*(cast(uint*)(_base2920 + 12))), + nbtData: _list2922, + placeOnBlocks: _witList2927, + destroyBlocks: _witList2932, + shieldBlockingTick: cast(long)(*(cast(ulong*)(_base2920 + (16+6*size_t.sizeof)))), + }; + _elem2920 = _record2933; + } + if (_listLen2934) deallocate ~= _listSrcPtr2934; + auto _witList2935 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.NetworkItemDescriptor)(_list2934); + wit.pumpkin.plugin.uuid.common.Uuid _record2936 = { + high: *(cast(ulong*)(_base2910 + (8+6*size_t.sizeof))), + low: *(cast(ulong*)(_base2910 + (16+6*size_t.sizeof))), + }; + auto _len2937 = *(cast(size_t*)(_base2910 + (24+7*size_t.sizeof))); + auto _ptr2937 = _len2937 ? cast(char*)(*(cast(void**)(_base2910 + (24+6*size_t.sizeof)))) : null; + if (_len2937) deallocate ~= cast()_ptr2937; + auto _list2938 = WitString(_ptr2937[0.._len2937]); + wit.pumpkin.plugin.bedrock_packets.common.RecipeUnlockRequirement _record2939 = { + context: cast(int)(*(cast(uint*)(_base2910 + (28+8*size_t.sizeof)))), + }; + wit.pumpkin.plugin.bedrock_packets.common.BedrockShapelessRecipe _record2940 = { + recipeId: _list2913, + input: _witList2919, + output: _witList2935, + uuid: _record2936, + block: _list2938, + priority: cast(int)(*(cast(uint*)(_base2910 + (24+8*size_t.sizeof)))), + unlockRequirement: _record2939, + recipeNetworkId: cast(int)(*(cast(uint*)(_base2910 + (32+8*size_t.sizeof)))), + }; + auto _payload2972 = _record2940; + _variant2971 = wit.pumpkin.plugin.bedrock_packets.common.BedrockRecipe.shapeless(_payload2972); + break; + } + case _Tag2971.shaped: { + auto _len2942 = *(cast(size_t*)(_base2910 + (8+1*size_t.sizeof))); + auto _ptr2942 = _len2942 ? cast(char*)(*(cast(void**)(_base2910 + 8))) : null; + if (_len2942) deallocate ~= cast()_ptr2942; + auto _list2943 = WitString(_ptr2942[0.._len2942]); + auto _listSrcPtr2948 = *(cast(void**)(_base2910 + (16+2*size_t.sizeof))); + auto _listLen2948 = *(cast(size_t*)(_base2910 + (16+3*size_t.sizeof))); + auto _list2948 = _listLen2948 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.ItemDescriptorCount)(_listLen2948) : []; + assert(!_listLen2948 || _list2948.ptr); + if (_listLen2948) deallocate ~= cast(void*)_list2948.ptr; + foreach (_elem2944_idx, ref _elem2944; _list2948) { + const auto _base2944 = _listSrcPtr2948 + _elem2944_idx * (8+2*size_t.sizeof); + auto _len2945 = *(cast(size_t*)(_base2944 + size_t.sizeof)); + auto _ptr2945 = _len2945 ? cast(char*)(*(cast(void**)(_base2944 + 0))) : null; + if (_len2945) deallocate ~= cast()_ptr2945; + auto _list2946 = WitString(_ptr2945[0.._len2945]); + wit.pumpkin.plugin.bedrock_packets.common.ItemDescriptorCount _record2947 = { + itemIdentifier: _list2946, + metadataValue: cast(int)(*(cast(uint*)(_base2944 + (2*size_t.sizeof)))), + count: cast(int)(*(cast(uint*)(_base2944 + (4+2*size_t.sizeof)))), + }; + _elem2944 = _record2947; + } + if (_listLen2948) deallocate ~= _listSrcPtr2948; + auto _witList2949 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.ItemDescriptorCount)(_list2948); + auto _listSrcPtr2964 = *(cast(void**)(_base2910 + (16+4*size_t.sizeof))); + auto _listLen2964 = *(cast(size_t*)(_base2910 + (16+5*size_t.sizeof))); + auto _list2964 = _listLen2964 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.NetworkItemDescriptor)(_listLen2964) : []; + assert(!_listLen2964 || _list2964.ptr); + if (_listLen2964) deallocate ~= cast(void*)_list2964.ptr; + foreach (_elem2950_idx, ref _elem2950; _list2964) { + const auto _base2950 = _listSrcPtr2964 + _elem2950_idx * (24+6*size_t.sizeof); + auto _len2951 = *(cast(size_t*)(_base2950 + (16+1*size_t.sizeof))); + auto _ptr2951 = _len2951 ? cast(char*)(*(cast(void**)(_base2950 + 16))) : null; + if (_len2951) deallocate ~= cast()_ptr2951; + auto _list2952 = WitString(_ptr2951[0.._len2951]); + auto _listSrcPtr2956 = *(cast(void**)(_base2950 + (16+2*size_t.sizeof))); + auto _listLen2956 = *(cast(size_t*)(_base2950 + (16+3*size_t.sizeof))); + auto _list2956 = _listLen2956 ? wit.common.mallocSlice!(WitString)(_listLen2956) : []; + assert(!_listLen2956 || _list2956.ptr); + if (_listLen2956) deallocate ~= cast(void*)_list2956.ptr; + foreach (_elem2953_idx, ref _elem2953; _list2956) { + const auto _base2953 = _listSrcPtr2956 + _elem2953_idx * (2*size_t.sizeof); + auto _len2954 = *(cast(size_t*)(_base2953 + size_t.sizeof)); + auto _ptr2954 = _len2954 ? cast(char*)(*(cast(void**)(_base2953 + 0))) : null; + if (_len2954) deallocate ~= cast()_ptr2954; + auto _list2955 = WitString(_ptr2954[0.._len2954]); + _elem2953 = _list2955; + } + if (_listLen2956) deallocate ~= _listSrcPtr2956; + auto _witList2957 = WitList!(WitString)(_list2956); + auto _listSrcPtr2961 = *(cast(void**)(_base2950 + (16+4*size_t.sizeof))); + auto _listLen2961 = *(cast(size_t*)(_base2950 + (16+5*size_t.sizeof))); + auto _list2961 = _listLen2961 ? wit.common.mallocSlice!(WitString)(_listLen2961) : []; + assert(!_listLen2961 || _list2961.ptr); + if (_listLen2961) deallocate ~= cast(void*)_list2961.ptr; + foreach (_elem2958_idx, ref _elem2958; _list2961) { + const auto _base2958 = _listSrcPtr2961 + _elem2958_idx * (2*size_t.sizeof); + auto _len2959 = *(cast(size_t*)(_base2958 + size_t.sizeof)); + auto _ptr2959 = _len2959 ? cast(char*)(*(cast(void**)(_base2958 + 0))) : null; + if (_len2959) deallocate ~= cast()_ptr2959; + auto _list2960 = WitString(_ptr2959[0.._len2959]); + _elem2958 = _list2960; + } + if (_listLen2961) deallocate ~= _listSrcPtr2961; + auto _witList2962 = WitList!(WitString)(_list2961); + wit.pumpkin.plugin.bedrock_packets.common.NetworkItemDescriptor _record2963 = { + id: cast(int)(*(cast(uint*)(_base2950 + 0))), + stackSize: cast(int)(*(cast(uint*)(_base2950 + 4))), + auxValue: cast(int)(*(cast(uint*)(_base2950 + 8))), + blockRuntimeId: cast(int)(*(cast(uint*)(_base2950 + 12))), + nbtData: _list2952, + placeOnBlocks: _witList2957, + destroyBlocks: _witList2962, + shieldBlockingTick: cast(long)(*(cast(ulong*)(_base2950 + (16+6*size_t.sizeof)))), + }; + _elem2950 = _record2963; + } + if (_listLen2964) deallocate ~= _listSrcPtr2964; + auto _witList2965 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.NetworkItemDescriptor)(_list2964); + wit.pumpkin.plugin.uuid.common.Uuid _record2966 = { + high: *(cast(ulong*)(_base2910 + (16+6*size_t.sizeof))), + low: *(cast(ulong*)(_base2910 + (24+6*size_t.sizeof))), + }; + auto _len2967 = *(cast(size_t*)(_base2910 + (32+7*size_t.sizeof))); + auto _ptr2967 = _len2967 ? cast(char*)(*(cast(void**)(_base2910 + (32+6*size_t.sizeof)))) : null; + if (_len2967) deallocate ~= cast()_ptr2967; + auto _list2968 = WitString(_ptr2967[0.._len2967]); + wit.pumpkin.plugin.bedrock_packets.common.RecipeUnlockRequirement _record2969 = { + context: cast(int)(*(cast(uint*)(_base2910 + (40+8*size_t.sizeof)))), + }; + wit.pumpkin.plugin.bedrock_packets.common.BedrockShapedRecipe _record2970 = { + recipeId: _list2943, + width: cast(int)(*(cast(uint*)(_base2910 + (8+2*size_t.sizeof)))), + height: cast(int)(*(cast(uint*)(_base2910 + (12+2*size_t.sizeof)))), + input: _witList2949, + output: _witList2965, + uuid: _record2966, + block: _list2968, + priority: cast(int)(*(cast(uint*)(_base2910 + (32+8*size_t.sizeof)))), + assumeSymmetry: (cast(uint)(*(cast(ubyte*)(_base2910 + (36+8*size_t.sizeof))))) != 0, + unlockRequirement: _record2969, + recipeNetworkId: cast(int)(*(cast(uint*)(_base2910 + (44+8*size_t.sizeof)))), + }; + auto _payload2973 = _record2970; + _variant2971 = wit.pumpkin.plugin.bedrock_packets.common.BedrockRecipe.shaped(_payload2973); + break; + } + } + _elem2910 = _variant2971; + } + if (_listLen2974) deallocate ~= _listSrcPtr2974; + auto _witList2975 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.BedrockRecipe)(_list2974); + wit.pumpkin.plugin.bedrock_packets.common.CCraftingData _record2976 = { + recipes: _witList2975, + cleanRecipes: (cast(uint)(*(cast(ubyte*)(arg0 + (40+2*size_t.sizeof))))) != 0, + }; + auto _payload3472 = _record2976; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cCraftingData(_payload3472); + break; + } + case _Tag3458.cCreativeContent: { + auto _listSrcPtr2995 = *(cast(void**)(arg0 + 40)); + auto _listLen2995 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _list2995 = _listLen2995 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.CreativeGroupInfoPayload)(_listLen2995) : []; + assert(!_listLen2995 || _list2995.ptr); + if (_listLen2995) deallocate ~= cast(void*)_list2995.ptr; + foreach (_elem2978_idx, ref _elem2978; _list2995) { + const auto _base2978 = _listSrcPtr2995 + _elem2978_idx * (32+8*size_t.sizeof); + auto _len2979 = *(cast(size_t*)(_base2978 + (2*size_t.sizeof))); + auto _ptr2979 = _len2979 ? cast(char*)(*(cast(void**)(_base2978 + size_t.sizeof))) : null; + if (_len2979) deallocate ~= cast()_ptr2979; + auto _list2980 = WitString(_ptr2979[0.._len2979]); + auto _len2981 = *(cast(size_t*)(_base2978 + (24+3*size_t.sizeof))); + auto _ptr2981 = _len2981 ? cast(char*)(*(cast(void**)(_base2978 + (24+2*size_t.sizeof)))) : null; + if (_len2981) deallocate ~= cast()_ptr2981; + auto _list2982 = WitString(_ptr2981[0.._len2981]); + auto _listSrcPtr2986 = *(cast(void**)(_base2978 + (24+4*size_t.sizeof))); + auto _listLen2986 = *(cast(size_t*)(_base2978 + (24+5*size_t.sizeof))); + auto _list2986 = _listLen2986 ? wit.common.mallocSlice!(WitString)(_listLen2986) : []; + assert(!_listLen2986 || _list2986.ptr); + if (_listLen2986) deallocate ~= cast(void*)_list2986.ptr; + foreach (_elem2983_idx, ref _elem2983; _list2986) { + const auto _base2983 = _listSrcPtr2986 + _elem2983_idx * (2*size_t.sizeof); + auto _len2984 = *(cast(size_t*)(_base2983 + size_t.sizeof)); + auto _ptr2984 = _len2984 ? cast(char*)(*(cast(void**)(_base2983 + 0))) : null; + if (_len2984) deallocate ~= cast()_ptr2984; + auto _list2985 = WitString(_ptr2984[0.._len2984]); + _elem2983 = _list2985; + } + if (_listLen2986) deallocate ~= _listSrcPtr2986; + auto _witList2987 = WitList!(WitString)(_list2986); + auto _listSrcPtr2991 = *(cast(void**)(_base2978 + (24+6*size_t.sizeof))); + auto _listLen2991 = *(cast(size_t*)(_base2978 + (24+7*size_t.sizeof))); + auto _list2991 = _listLen2991 ? wit.common.mallocSlice!(WitString)(_listLen2991) : []; + assert(!_listLen2991 || _list2991.ptr); + if (_listLen2991) deallocate ~= cast(void*)_list2991.ptr; + foreach (_elem2988_idx, ref _elem2988; _list2991) { + const auto _base2988 = _listSrcPtr2991 + _elem2988_idx * (2*size_t.sizeof); + auto _len2989 = *(cast(size_t*)(_base2988 + size_t.sizeof)); + auto _ptr2989 = _len2989 ? cast(char*)(*(cast(void**)(_base2988 + 0))) : null; + if (_len2989) deallocate ~= cast()_ptr2989; + auto _list2990 = WitString(_ptr2989[0.._len2989]); + _elem2988 = _list2990; + } + if (_listLen2991) deallocate ~= _listSrcPtr2991; + auto _witList2992 = WitList!(WitString)(_list2991); + wit.pumpkin.plugin.bedrock_packets.common.NetworkItemDescriptor _record2993 = { + id: cast(int)(*(cast(uint*)(_base2978 + (8+2*size_t.sizeof)))), + stackSize: cast(int)(*(cast(uint*)(_base2978 + (12+2*size_t.sizeof)))), + auxValue: cast(int)(*(cast(uint*)(_base2978 + (16+2*size_t.sizeof)))), + blockRuntimeId: cast(int)(*(cast(uint*)(_base2978 + (20+2*size_t.sizeof)))), + nbtData: _list2982, + placeOnBlocks: _witList2987, + destroyBlocks: _witList2992, + shieldBlockingTick: cast(long)(*(cast(ulong*)(_base2978 + (24+8*size_t.sizeof)))), + }; + wit.pumpkin.plugin.bedrock_packets.common.CreativeGroupInfoPayload _record2994 = { + creativeCategory: cast(wit.pumpkin.plugin.bedrock_packets.common.CreativeCategory)(cast(uint)(*(cast(ubyte*)(_base2978 + 0)))), + name: _list2980, + groupIconItem: _record2993, + }; + _elem2978 = _record2994; + } + if (_listLen2995) deallocate ~= _listSrcPtr2995; + auto _witList2996 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.CreativeGroupInfoPayload)(_list2995); + auto _listSrcPtr3012 = *(cast(void**)(arg0 + (40+2*size_t.sizeof))); + auto _listLen3012 = *(cast(size_t*)(arg0 + (40+3*size_t.sizeof))); + auto _list3012 = _listLen3012 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.CreativeItemEntryPayload)(_listLen3012) : []; + assert(!_listLen3012 || _list3012.ptr); + if (_listLen3012) deallocate ~= cast(void*)_list3012.ptr; + foreach (_elem2997_idx, ref _elem2997; _list3012) { + const auto _base2997 = _listSrcPtr3012 + _elem2997_idx * (40+6*size_t.sizeof); + auto _len2998 = *(cast(size_t*)(_base2997 + (24+1*size_t.sizeof))); + auto _ptr2998 = _len2998 ? cast(char*)(*(cast(void**)(_base2997 + 24))) : null; + if (_len2998) deallocate ~= cast()_ptr2998; + auto _list2999 = WitString(_ptr2998[0.._len2998]); + auto _listSrcPtr3003 = *(cast(void**)(_base2997 + (24+2*size_t.sizeof))); + auto _listLen3003 = *(cast(size_t*)(_base2997 + (24+3*size_t.sizeof))); + auto _list3003 = _listLen3003 ? wit.common.mallocSlice!(WitString)(_listLen3003) : []; + assert(!_listLen3003 || _list3003.ptr); + if (_listLen3003) deallocate ~= cast(void*)_list3003.ptr; + foreach (_elem3000_idx, ref _elem3000; _list3003) { + const auto _base3000 = _listSrcPtr3003 + _elem3000_idx * (2*size_t.sizeof); + auto _len3001 = *(cast(size_t*)(_base3000 + size_t.sizeof)); + auto _ptr3001 = _len3001 ? cast(char*)(*(cast(void**)(_base3000 + 0))) : null; + if (_len3001) deallocate ~= cast()_ptr3001; + auto _list3002 = WitString(_ptr3001[0.._len3001]); + _elem3000 = _list3002; + } + if (_listLen3003) deallocate ~= _listSrcPtr3003; + auto _witList3004 = WitList!(WitString)(_list3003); + auto _listSrcPtr3008 = *(cast(void**)(_base2997 + (24+4*size_t.sizeof))); + auto _listLen3008 = *(cast(size_t*)(_base2997 + (24+5*size_t.sizeof))); + auto _list3008 = _listLen3008 ? wit.common.mallocSlice!(WitString)(_listLen3008) : []; + assert(!_listLen3008 || _list3008.ptr); + if (_listLen3008) deallocate ~= cast(void*)_list3008.ptr; + foreach (_elem3005_idx, ref _elem3005; _list3008) { + const auto _base3005 = _listSrcPtr3008 + _elem3005_idx * (2*size_t.sizeof); + auto _len3006 = *(cast(size_t*)(_base3005 + size_t.sizeof)); + auto _ptr3006 = _len3006 ? cast(char*)(*(cast(void**)(_base3005 + 0))) : null; + if (_len3006) deallocate ~= cast()_ptr3006; + auto _list3007 = WitString(_ptr3006[0.._len3006]); + _elem3005 = _list3007; + } + if (_listLen3008) deallocate ~= _listSrcPtr3008; + auto _witList3009 = WitList!(WitString)(_list3008); + wit.pumpkin.plugin.bedrock_packets.common.NetworkItemDescriptor _record3010 = { + id: cast(int)(*(cast(uint*)(_base2997 + 8))), + stackSize: cast(int)(*(cast(uint*)(_base2997 + 12))), + auxValue: cast(int)(*(cast(uint*)(_base2997 + 16))), + blockRuntimeId: cast(int)(*(cast(uint*)(_base2997 + 20))), + nbtData: _list2999, + placeOnBlocks: _witList3004, + destroyBlocks: _witList3009, + shieldBlockingTick: cast(long)(*(cast(ulong*)(_base2997 + (24+6*size_t.sizeof)))), + }; + wit.pumpkin.plugin.bedrock_packets.common.CreativeItemEntryPayload _record3011 = { + id: cast(int)(*(cast(uint*)(_base2997 + 0))), + item: _record3010, + groupIndex: cast(int)(*(cast(uint*)(_base2997 + (32+6*size_t.sizeof)))), + }; + _elem2997 = _record3011; + } + if (_listLen3012) deallocate ~= _listSrcPtr3012; + auto _witList3013 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.CreativeItemEntryPayload)(_list3012); + wit.pumpkin.plugin.bedrock_packets.common.CCreativeContent _record3014 = { + groups: _witList2996, + entries: _witList3013, + }; + auto _payload3473 = _record3014; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cCreativeContent(_payload3473); + break; + } + case _Tag3458.cDisconnect: { + auto _len3016 = *(cast(size_t*)(arg0 + (48+1*size_t.sizeof))); + auto _ptr3016 = _len3016 ? cast(char*)(*(cast(void**)(arg0 + 48))) : null; + if (_len3016) deallocate ~= cast()_ptr3016; + auto _list3017 = WitString(_ptr3016[0.._len3016]); + auto _len3018 = *(cast(size_t*)(arg0 + (48+3*size_t.sizeof))); + auto _ptr3018 = _len3018 ? cast(char*)(*(cast(void**)(arg0 + (48+2*size_t.sizeof)))) : null; + if (_len3018) deallocate ~= cast()_ptr3018; + auto _list3019 = WitString(_ptr3018[0.._len3018]); + wit.pumpkin.plugin.bedrock_packets.common.CDisconnect _record3020 = { + reason: cast(int)(*(cast(uint*)(arg0 + 40))), + skipMessage: (cast(uint)(*(cast(ubyte*)(arg0 + 44)))) != 0, + message: _list3017, + filteredMessage: _list3019, + }; + auto _payload3474 = _record3020; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cDisconnect(_payload3474); + break; + } + case _Tag3458.cGamerulesChanged: { + auto _listSrcPtr3026 = *(cast(void**)(arg0 + 40)); + auto _listLen3026 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _list3026 = _listLen3026 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.GameRule)(_listLen3026) : []; + assert(!_listLen3026 || _list3026.ptr); + if (_listLen3026) deallocate ~= cast(void*)_list3026.ptr; + foreach (_elem3022_idx, ref _elem3022; _list3026) { + const auto _base3022 = _listSrcPtr3026 + _elem3022_idx * (3*size_t.sizeof); + auto _len3023 = *(cast(size_t*)(_base3022 + size_t.sizeof)); + auto _ptr3023 = _len3023 ? cast(char*)(*(cast(void**)(_base3022 + 0))) : null; + if (_len3023) deallocate ~= cast()_ptr3023; + auto _list3024 = WitString(_ptr3023[0.._len3023]); + wit.pumpkin.plugin.bedrock_packets.common.GameRule _record3025 = { + ruleName: _list3024, + ruleCanBeModified: (cast(uint)(*(cast(ubyte*)(_base3022 + (2*size_t.sizeof))))) != 0, + ruleValue: cast(wit.pumpkin.plugin.bedrock_packets.common.RuleValue)(cast(uint)(*(cast(ubyte*)(_base3022 + (1+2*size_t.sizeof))))), + }; + _elem3022 = _record3025; + } + if (_listLen3026) deallocate ~= _listSrcPtr3026; + auto _witList3027 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.GameRule)(_list3026); + wit.pumpkin.plugin.bedrock_packets.common.CGamerulesChanged _record3028 = { + ruleData: _witList3027, + }; + auto _payload3475 = _record3028; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cGamerulesChanged(_payload3475); + break; + } + case _Tag3458.cInventoryContent: { + auto _listSrcPtr3037 = *(cast(void**)(arg0 + (40+1*size_t.sizeof))); + auto _listLen3037 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _list3037 = _listLen3037 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.NetworkItemStackDescriptor)(_listLen3037) : []; + assert(!_listLen3037 || _list3037.ptr); + if (_listLen3037) deallocate ~= cast(void*)_list3037.ptr; + foreach (_elem3030_idx, ref _elem3030; _list3037) { + const auto _base3030 = _listSrcPtr3037 + _elem3030_idx * (24+2*size_t.sizeof); + auto _len3031 = *(cast(size_t*)(_base3030 + (16+1*size_t.sizeof))); + auto _ptr3031 = _len3031 ? cast(ubyte*)(*(cast(void**)(_base3030 + 16))) : null; + if (_len3031) deallocate ~= cast()_ptr3031; + auto _list3032 = WitList!(ubyte)(_ptr3031[0.._len3031]); + Option!(int) _option3035 = void; + bool _isSome3035 = (cast(uint)(*(cast(ubyte*)(_base3030 + (16+2*size_t.sizeof))))) != 0; + if (_isSome3035) { + + _option3035 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base3030 + (20+2*size_t.sizeof))))); + } else { + _option3035 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.NetworkItemStackDescriptor _record3036 = { + id: cast(int)(*(cast(uint*)(_base3030 + 0))), + stackSize: cast(int)(*(cast(uint*)(_base3030 + 4))), + auxValue: cast(int)(*(cast(uint*)(_base3030 + 8))), + blockRuntimeId: cast(int)(*(cast(uint*)(_base3030 + 12))), + extraData: _list3032, + netId: _option3035, + }; + _elem3030 = _record3036; + } + if (_listLen3037) deallocate ~= _listSrcPtr3037; + auto _witList3038 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.NetworkItemStackDescriptor)(_list3037); + Option!(int) _option3041 = void; + bool _isSome3041 = (cast(uint)(*(cast(ubyte*)(arg0 + (44+3*size_t.sizeof))))) != 0; + if (_isSome3041) { + + _option3041 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + (48+3*size_t.sizeof))))); + } else { + _option3041 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.FullContainerName _record3042 = { + containerName: cast(wit.pumpkin.plugin.bedrock_packets.common.ContainerName)(cast(uint)(*(cast(ubyte*)(arg0 + (40+3*size_t.sizeof))))), + dynamicId: _option3041, + }; + auto _len3043 = *(cast(size_t*)(arg0 + (64+5*size_t.sizeof))); + auto _ptr3043 = _len3043 ? cast(ubyte*)(*(cast(void**)(arg0 + (64+4*size_t.sizeof)))) : null; + if (_len3043) deallocate ~= cast()_ptr3043; + auto _list3044 = WitList!(ubyte)(_ptr3043[0.._len3043]); + Option!(int) _option3047 = void; + bool _isSome3047 = (cast(uint)(*(cast(ubyte*)(arg0 + (64+6*size_t.sizeof))))) != 0; + if (_isSome3047) { + + _option3047 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + (68+6*size_t.sizeof))))); + } else { + _option3047 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.NetworkItemStackDescriptor _record3048 = { + id: cast(int)(*(cast(uint*)(arg0 + (48+4*size_t.sizeof)))), + stackSize: cast(int)(*(cast(uint*)(arg0 + (52+4*size_t.sizeof)))), + auxValue: cast(int)(*(cast(uint*)(arg0 + (56+4*size_t.sizeof)))), + blockRuntimeId: cast(int)(*(cast(uint*)(arg0 + (60+4*size_t.sizeof)))), + extraData: _list3044, + netId: _option3047, + }; + wit.pumpkin.plugin.bedrock_packets.common.CInventoryContent _record3049 = { + containerId: cast(int)(*(cast(uint*)(arg0 + 40))), + slots: _witList3038, + fullContainerName: _record3042, + storageItem: _record3048, + }; + auto _payload3476 = _record3049; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cInventoryContent(_payload3476); + break; + } + case _Tag3458.cInventorySlot: { + Option!(wit.pumpkin.plugin.bedrock_packets.common.FullContainerName) _option3057 = void; + bool _isSome3057 = (cast(uint)(*(cast(ubyte*)(arg0 + 48)))) != 0; + if (_isSome3057) { + Option!(int) _option3055 = void; + bool _isSome3055 = (cast(uint)(*(cast(ubyte*)(arg0 + 56)))) != 0; + if (_isSome3055) { + + _option3055 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + 60)))); + } else { + _option3055 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.FullContainerName _record3056 = { + containerName: cast(wit.pumpkin.plugin.bedrock_packets.common.ContainerName)(cast(uint)(*(cast(ubyte*)(arg0 + 52)))), + dynamicId: _option3055, + }; + + _option3057 = Option!(wit.pumpkin.plugin.bedrock_packets.common.FullContainerName).makeSome(_record3056); + } else { + _option3057 = Option!(wit.pumpkin.plugin.bedrock_packets.common.FullContainerName).makeNone; + } + Option!(wit.pumpkin.plugin.bedrock_packets.common.NetworkItemStackDescriptor) _option3066 = void; + bool _isSome3066 = (cast(uint)(*(cast(ubyte*)(arg0 + 64)))) != 0; + if (_isSome3066) { + auto _len3060 = *(cast(size_t*)(arg0 + (80+2*size_t.sizeof))); + auto _ptr3060 = _len3060 ? cast(ubyte*)(*(cast(void**)(arg0 + (80+1*size_t.sizeof)))) : null; + if (_len3060) deallocate ~= cast()_ptr3060; + auto _list3061 = WitList!(ubyte)(_ptr3060[0.._len3060]); + Option!(int) _option3064 = void; + bool _isSome3064 = (cast(uint)(*(cast(ubyte*)(arg0 + (80+3*size_t.sizeof))))) != 0; + if (_isSome3064) { + + _option3064 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + (84+3*size_t.sizeof))))); + } else { + _option3064 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.NetworkItemStackDescriptor _record3065 = { + id: cast(int)(*(cast(uint*)(arg0 + (64+1*size_t.sizeof)))), + stackSize: cast(int)(*(cast(uint*)(arg0 + (68+1*size_t.sizeof)))), + auxValue: cast(int)(*(cast(uint*)(arg0 + (72+1*size_t.sizeof)))), + blockRuntimeId: cast(int)(*(cast(uint*)(arg0 + (76+1*size_t.sizeof)))), + extraData: _list3061, + netId: _option3064, + }; + + _option3066 = Option!(wit.pumpkin.plugin.bedrock_packets.common.NetworkItemStackDescriptor).makeSome(_record3065); + } else { + _option3066 = Option!(wit.pumpkin.plugin.bedrock_packets.common.NetworkItemStackDescriptor).makeNone; + } + auto _len3067 = *(cast(size_t*)(arg0 + (104+4*size_t.sizeof))); + auto _ptr3067 = _len3067 ? cast(ubyte*)(*(cast(void**)(arg0 + (104+3*size_t.sizeof)))) : null; + if (_len3067) deallocate ~= cast()_ptr3067; + auto _list3068 = WitList!(ubyte)(_ptr3067[0.._len3067]); + Option!(int) _option3071 = void; + bool _isSome3071 = (cast(uint)(*(cast(ubyte*)(arg0 + (104+5*size_t.sizeof))))) != 0; + if (_isSome3071) { + + _option3071 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + (108+5*size_t.sizeof))))); + } else { + _option3071 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.NetworkItemStackDescriptor _record3072 = { + id: cast(int)(*(cast(uint*)(arg0 + (88+3*size_t.sizeof)))), + stackSize: cast(int)(*(cast(uint*)(arg0 + (92+3*size_t.sizeof)))), + auxValue: cast(int)(*(cast(uint*)(arg0 + (96+3*size_t.sizeof)))), + blockRuntimeId: cast(int)(*(cast(uint*)(arg0 + (100+3*size_t.sizeof)))), + extraData: _list3068, + netId: _option3071, + }; + wit.pumpkin.plugin.bedrock_packets.common.CInventorySlot _record3073 = { + containerId: cast(int)(*(cast(uint*)(arg0 + 40))), + slot: cast(int)(*(cast(uint*)(arg0 + 44))), + fullContainerName: _option3057, + storageItem: _option3066, + item: _record3072, + }; + auto _payload3477 = _record3073; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cInventorySlot(_payload3477); + break; + } + case _Tag3458.cItemRegistry: { + auto _listSrcPtr3081 = *(cast(void**)(arg0 + 40)); + auto _listLen3081 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _list3081 = _listLen3081 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.ItemData)(_listLen3081) : []; + assert(!_listLen3081 || _list3081.ptr); + if (_listLen3081) deallocate ~= cast(void*)_list3081.ptr; + foreach (_elem3075_idx, ref _elem3075; _list3081) { + const auto _base3075 = _listSrcPtr3081 + _elem3075_idx * (8+5*size_t.sizeof); + auto _len3076 = *(cast(size_t*)(_base3075 + size_t.sizeof)); + auto _ptr3076 = _len3076 ? cast(char*)(*(cast(void**)(_base3075 + 0))) : null; + if (_len3076) deallocate ~= cast()_ptr3076; + auto _list3077 = WitString(_ptr3076[0.._len3076]); + auto _len3078 = *(cast(size_t*)(_base3075 + (8+4*size_t.sizeof))); + auto _ptr3078 = _len3078 ? cast(ubyte*)(*(cast(void**)(_base3075 + (8+3*size_t.sizeof)))) : null; + if (_len3078) deallocate ~= cast()_ptr3078; + auto _list3079 = WitList!(ubyte)(_ptr3078[0.._len3078]); + wit.pumpkin.plugin.bedrock_packets.common.ItemData _record3080 = { + itemName: _list3077, + itemId: cast(int)(*(cast(uint*)(_base3075 + (2*size_t.sizeof)))), + isComponentBased: (cast(uint)(*(cast(ubyte*)(_base3075 + (4+2*size_t.sizeof))))) != 0, + itemVersion: cast(int)(*(cast(uint*)(_base3075 + (8+2*size_t.sizeof)))), + componentData: _list3079, + }; + _elem3075 = _record3080; + } + if (_listLen3081) deallocate ~= _listSrcPtr3081; + auto _witList3082 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.ItemData)(_list3081); + wit.pumpkin.plugin.bedrock_packets.common.CItemRegistry _record3083 = { + items: _witList3082, + }; + auto _payload3478 = _record3083; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cItemRegistry(_payload3478); + break; + } + case _Tag3458.cItemStackResponse: { + auto _listSrcPtr3103 = *(cast(void**)(arg0 + 40)); + auto _listLen3103 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _list3103 = _listLen3103 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.ItemStackResponseInfo)(_listLen3103) : []; + assert(!_listLen3103 || _list3103.ptr); + if (_listLen3103) deallocate ~= cast(void*)_list3103.ptr; + foreach (_elem3085_idx, ref _elem3085; _list3103) { + const auto _base3085 = _listSrcPtr3103 + _elem3085_idx * (8+2*size_t.sizeof); + auto _listSrcPtr3100 = *(cast(void**)(_base3085 + 8)); + auto _listLen3100 = *(cast(size_t*)(_base3085 + (8+1*size_t.sizeof))); + auto _list3100 = _listLen3100 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.ItemStackResponseContainerInfo)(_listLen3100) : []; + assert(!_listLen3100 || _list3100.ptr); + if (_listLen3100) deallocate ~= cast(void*)_list3100.ptr; + foreach (_elem3086_idx, ref _elem3086; _list3100) { + const auto _base3086 = _listSrcPtr3100 + _elem3086_idx * (8+3*size_t.sizeof); + Option!(int) _option3089 = void; + bool _isSome3089 = (cast(uint)(*(cast(ubyte*)(_base3086 + 4)))) != 0; + if (_isSome3089) { + + _option3089 = Option!(int).makeSome(cast(int)(*(cast(uint*)(_base3086 + 8)))); + } else { + _option3089 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.FullContainerName _record3090 = { + containerName: cast(wit.pumpkin.plugin.bedrock_packets.common.ContainerName)(cast(uint)(*(cast(ubyte*)(_base3086 + 0)))), + dynamicId: _option3089, + }; + auto _listSrcPtr3097 = *(cast(void**)(_base3086 + (8+1*size_t.sizeof))); + auto _listLen3097 = *(cast(size_t*)(_base3086 + (8+2*size_t.sizeof))); + auto _list3097 = _listLen3097 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.ItemStackResponseSlotInfo)(_listLen3097) : []; + assert(!_listLen3097 || _list3097.ptr); + if (_listLen3097) deallocate ~= cast(void*)_list3097.ptr; + foreach (_elem3091_idx, ref _elem3091; _list3097) { + const auto _base3091 = _listSrcPtr3097 + _elem3091_idx * (8+5*size_t.sizeof); + auto _len3092 = *(cast(size_t*)(_base3091 + (8+1*size_t.sizeof))); + auto _ptr3092 = _len3092 ? cast(char*)(*(cast(void**)(_base3091 + 8))) : null; + if (_len3092) deallocate ~= cast()_ptr3092; + auto _list3093 = WitString(_ptr3092[0.._len3092]); + auto _len3094 = *(cast(size_t*)(_base3091 + (8+3*size_t.sizeof))); + auto _ptr3094 = _len3094 ? cast(char*)(*(cast(void**)(_base3091 + (8+2*size_t.sizeof)))) : null; + if (_len3094) deallocate ~= cast()_ptr3094; + auto _list3095 = WitString(_ptr3094[0.._len3094]); + wit.pumpkin.plugin.bedrock_packets.common.ItemStackResponseSlotInfo _record3096 = { + requestedSlot: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base3091 + 0)))), + slot: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base3091 + 1)))), + amount: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base3091 + 2)))), + itemStackNetId: cast(int)(*(cast(uint*)(_base3091 + 4))), + customName: _list3093, + filteredCustomName: _list3095, + durabilityCorrection: cast(int)(*(cast(uint*)(_base3091 + (8+4*size_t.sizeof)))), + }; + _elem3091 = _record3096; + } + if (_listLen3097) deallocate ~= _listSrcPtr3097; + auto _witList3098 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.ItemStackResponseSlotInfo)(_list3097); + wit.pumpkin.plugin.bedrock_packets.common.ItemStackResponseContainerInfo _record3099 = { + fullContainerName: _record3090, + slots: _witList3098, + }; + _elem3086 = _record3099; + } + if (_listLen3100) deallocate ~= _listSrcPtr3100; + auto _witList3101 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.ItemStackResponseContainerInfo)(_list3100); + wit.pumpkin.plugin.bedrock_packets.common.ItemStackResponseInfo _record3102 = { + result: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base3085 + 0)))), + clientRequestId: cast(int)(*(cast(uint*)(_base3085 + 4))), + containers: _witList3101, + }; + _elem3085 = _record3102; + } + if (_listLen3103) deallocate ~= _listSrcPtr3103; + auto _witList3104 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.ItemStackResponseInfo)(_list3103); + wit.pumpkin.plugin.bedrock_packets.common.CItemStackResponse _record3105 = { + responses: _witList3104, + }; + auto _payload3479 = _record3105; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cItemStackResponse(_payload3479); + break; + } + case _Tag3458.cLevelChunk: { + auto _len3107 = *(cast(size_t*)(arg0 + (48+1*size_t.sizeof))); + auto _ptr3107 = _len3107 ? cast(ubyte*)(*(cast(void**)(arg0 + 48))) : null; + if (_len3107) deallocate ~= cast()_ptr3107; + auto _list3108 = WitList!(ubyte)(_ptr3107[0.._len3107]); + auto _listSrcPtr3112 = *(cast(void**)(arg0 + (48+2*size_t.sizeof))); + auto _listLen3112 = *(cast(size_t*)(arg0 + (48+3*size_t.sizeof))); + auto _list3112 = _listLen3112 ? wit.common.mallocSlice!(WitString)(_listLen3112) : []; + assert(!_listLen3112 || _list3112.ptr); + if (_listLen3112) deallocate ~= cast(void*)_list3112.ptr; + foreach (_elem3109_idx, ref _elem3109; _list3112) { + const auto _base3109 = _listSrcPtr3112 + _elem3109_idx * (2*size_t.sizeof); + auto _len3110 = *(cast(size_t*)(_base3109 + size_t.sizeof)); + auto _ptr3110 = _len3110 ? cast(char*)(*(cast(void**)(_base3109 + 0))) : null; + if (_len3110) deallocate ~= cast()_ptr3110; + auto _list3111 = WitString(_ptr3110[0.._len3110]); + _elem3109 = _list3111; + } + if (_listLen3112) deallocate ~= _listSrcPtr3112; + auto _witList3113 = WitList!(WitString)(_list3112); + wit.pumpkin.plugin.bedrock_packets.common.CLevelChunk _record3114 = { + dimension: cast(int)(*(cast(uint*)(arg0 + 40))), + cacheEnabled: (cast(uint)(*(cast(ubyte*)(arg0 + 44)))) != 0, + chunk: _list3108, + blockActors: _witList3113, + }; + auto _payload3480 = _record3114; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cLevelChunk(_payload3480); + break; + } + case _Tag3458.cLevelEvent: { + auto _tuple3116 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 48)), + *(cast(double*)(arg0 + 56)), + *(cast(double*)(arg0 + 64)), + ); + wit.pumpkin.plugin.bedrock_packets.common.CLevelEvent _record3117 = { + eventId: cast(int)(*(cast(uint*)(arg0 + 40))), + position: _tuple3116, + data: cast(int)(*(cast(uint*)(arg0 + 72))), + }; + auto _payload3481 = _record3117; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cLevelEvent(_payload3481); + break; + } + case _Tag3458.cLevelSoundEvent: { + auto _len3119 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr3119 = _len3119 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len3119) deallocate ~= cast()_ptr3119; + auto _list3120 = WitString(_ptr3119[0.._len3119]); + auto _tuple3121 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + (40+2*size_t.sizeof))), + *(cast(double*)(arg0 + (48+2*size_t.sizeof))), + *(cast(double*)(arg0 + (56+2*size_t.sizeof))), + ); + auto _len3122 = *(cast(size_t*)(arg0 + (64+4*size_t.sizeof))); + auto _ptr3122 = _len3122 ? cast(char*)(*(cast(void**)(arg0 + (64+3*size_t.sizeof)))) : null; + if (_len3122) deallocate ~= cast()_ptr3122; + auto _list3123 = WitString(_ptr3122[0.._len3122]); + Option!(Tuple!(double, double, double)) _option3127 = void; + bool _isSome3127 = (cast(uint)(*(cast(ubyte*)(arg0 + (72+6*size_t.sizeof))))) != 0; + if (_isSome3127) { + auto _tuple3126 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + (80+6*size_t.sizeof))), + *(cast(double*)(arg0 + (88+6*size_t.sizeof))), + *(cast(double*)(arg0 + (96+6*size_t.sizeof))), + ); + + _option3127 = Option!(Tuple!(double, double, double)).makeSome(_tuple3126); + } else { + _option3127 = Option!(Tuple!(double, double, double)).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.CLevelSoundEvent _record3128 = { + soundEvent: _list3120, + position: _tuple3121, + data: cast(int)(*(cast(uint*)(arg0 + (64+2*size_t.sizeof)))), + actorIdentifier: _list3123, + isBaby: (cast(uint)(*(cast(ubyte*)(arg0 + (64+5*size_t.sizeof))))) != 0, + isGlobal: (cast(uint)(*(cast(ubyte*)(arg0 + (65+5*size_t.sizeof))))) != 0, + actorUniqueId: cast(long)(*(cast(ulong*)(arg0 + (64+6*size_t.sizeof)))), + fireAtPosition: _option3127, + }; + auto _payload3482 = _record3128; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cLevelSoundEvent(_payload3482); + break; + } + case _Tag3458.cMobEffect: { + wit.pumpkin.plugin.bedrock_packets.common.CMobEffect _record3130 = { + targetRuntimeId: cast(long)(*(cast(ulong*)(arg0 + 40))), + eventId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 48)))), + effectId: cast(int)(*(cast(uint*)(arg0 + 52))), + effectAmplifier: cast(int)(*(cast(uint*)(arg0 + 56))), + showParticles: (cast(uint)(*(cast(ubyte*)(arg0 + 60)))) != 0, + effectDurationTicks: cast(int)(*(cast(uint*)(arg0 + 64))), + tick: cast(long)(*(cast(ulong*)(arg0 + 72))), + ambient: (cast(uint)(*(cast(ubyte*)(arg0 + 80)))) != 0, + }; + auto _payload3483 = _record3130; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cMobEffect(_payload3483); + break; + } + case _Tag3458.cMobEquipment: { + auto _len3132 = *(cast(size_t*)(arg0 + (64+1*size_t.sizeof))); + auto _ptr3132 = _len3132 ? cast(ubyte*)(*(cast(void**)(arg0 + 64))) : null; + if (_len3132) deallocate ~= cast()_ptr3132; + auto _list3133 = WitList!(ubyte)(_ptr3132[0.._len3132]); + Option!(int) _option3136 = void; + bool _isSome3136 = (cast(uint)(*(cast(ubyte*)(arg0 + (64+2*size_t.sizeof))))) != 0; + if (_isSome3136) { + + _option3136 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + (68+2*size_t.sizeof))))); + } else { + _option3136 = Option!(int).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.NetworkItemStackDescriptor _record3137 = { + id: cast(int)(*(cast(uint*)(arg0 + 48))), + stackSize: cast(int)(*(cast(uint*)(arg0 + 52))), + auxValue: cast(int)(*(cast(uint*)(arg0 + 56))), + blockRuntimeId: cast(int)(*(cast(uint*)(arg0 + 60))), + extraData: _list3133, + netId: _option3136, + }; + wit.pumpkin.plugin.bedrock_packets.common.CMobEquipment _record3138 = { + targetRuntimeId: cast(long)(*(cast(ulong*)(arg0 + 40))), + item: _record3137, + slot: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (72+2*size_t.sizeof))))), + selectedSlot: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (73+2*size_t.sizeof))))), + containerId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (74+2*size_t.sizeof))))), + }; + auto _payload3484 = _record3138; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cMobEquipment(_payload3484); + break; + } + case _Tag3458.cModalFormRequest: { + auto _len3140 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _ptr3140 = _len3140 ? cast(char*)(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))) : null; + if (_len3140) deallocate ~= cast()_ptr3140; + auto _list3141 = WitString(_ptr3140[0.._len3140]); + wit.pumpkin.plugin.bedrock_packets.common.CModalFormRequest _record3142 = { + formId: cast(int)(*(cast(uint*)(arg0 + 40))), + formUiJson: _list3141, + }; + auto _payload3485 = _record3142; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cModalFormRequest(_payload3485); + break; + } + case _Tag3458.cMoveActorAbsolute: { + auto _tuple3144 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 56)), + *(cast(double*)(arg0 + 64)), + *(cast(double*)(arg0 + 72)), + ); + wit.pumpkin.plugin.bedrock_packets.common.CMoveActorAbsolute _record3145 = { + actorRuntimeId: cast(long)(*(cast(ulong*)(arg0 + 40))), + header: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 48)))), + position: _tuple3144, + rotationX: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 80)))), + rotationY: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 81)))), + rotationYHead: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 82)))), + }; + auto _payload3486 = _record3145; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cMoveActorAbsolute(_payload3486); + break; + } + case _Tag3458.cMoveActorDelta: { + wit.pumpkin.plugin.bedrock_packets.common.CMoveActorDelta _record3147 = { + entityRuntimeId: cast(long)(*(cast(ulong*)(arg0 + 40))), + flags: cast(int)(*(cast(uint*)(arg0 + 48))), + x: *(cast(float*)(arg0 + 52)), + y: *(cast(float*)(arg0 + 56)), + z: *(cast(float*)(arg0 + 60)), + pitch: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 64)))), + yaw: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 65)))), + headYaw: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 66)))), + }; + auto _payload3487 = _record3147; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cMoveActorDelta(_payload3487); + break; + } + case _Tag3458.cMovePlayer: { + auto _tuple3149 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 48)), + *(cast(double*)(arg0 + 56)), + *(cast(double*)(arg0 + 64)), + ); + wit.pumpkin.plugin.bedrock_packets.common.CMovePlayer _record3150 = { + playerRuntimeId: cast(long)(*(cast(ulong*)(arg0 + 40))), + position: _tuple3149, + pitch: *(cast(float*)(arg0 + 72)), + yaw: *(cast(float*)(arg0 + 76)), + headYaw: *(cast(float*)(arg0 + 80)), + mode: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 84)))), + onGround: (cast(uint)(*(cast(ubyte*)(arg0 + 85)))) != 0, + ridingRuntimeId: cast(long)(*(cast(ulong*)(arg0 + 88))), + teleportCause: cast(int)(*(cast(uint*)(arg0 + 96))), + teleportSourceEntityType: cast(int)(*(cast(uint*)(arg0 + 100))), + tick: cast(long)(*(cast(ulong*)(arg0 + 104))), + }; + auto _payload3488 = _record3150; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cMovePlayer(_payload3488); + break; + } + case _Tag3458.cNetworkChunkPublisherUpdate: { + auto _tuple3152 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 40))), + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + ); + auto _len3153 = *(cast(size_t*)(arg0 + (56+1*size_t.sizeof))); + auto _ptr3153 = _len3153 ? cast(Tuple!(double, double)*)(*(cast(void**)(arg0 + 56))) : null; + if (_len3153) deallocate ~= cast()_ptr3153; + auto _list3154 = WitList!(Tuple!(double, double))(_ptr3153[0.._len3153]); + wit.pumpkin.plugin.bedrock_packets.common.CNetworkChunkPublisherUpdate _record3155 = { + posForView: _tuple3152, + newRadius: cast(int)(*(cast(uint*)(arg0 + 52))), + serverBuildChunkList: _list3154, + }; + auto _payload3489 = _record3155; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cNetworkChunkPublisherUpdate(_payload3489); + break; + } + case _Tag3458.cNetworkSettings: { + wit.pumpkin.plugin.bedrock_packets.common.CNetworkSettings _record3157 = { + compressionThreshold: cast(int)(*(cast(uint*)(arg0 + 40))), + compressionAlgorithm: cast(int)(*(cast(uint*)(arg0 + 44))), + clientThrottleEnabled: (cast(uint)(*(cast(ubyte*)(arg0 + 48)))) != 0, + clientThrottleThreshold: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 49)))), + clientThrottleScalar: *(cast(float*)(arg0 + 52)), + }; + auto _payload3490 = _record3157; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cNetworkSettings(_payload3490); + break; + } + case _Tag3458.cPlayStatus: { + auto _payload3491 = cast(wit.pumpkin.plugin.bedrock_packets.common.CPlayStatus)(cast(uint)(*(cast(ubyte*)(arg0 + 40)))); + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cPlayStatus(_payload3491); + break; + } + case _Tag3458.cPlayerHotbar: { + wit.pumpkin.plugin.bedrock_packets.common.CPlayerHotbar _record3160 = { + selectedSlot: cast(int)(*(cast(uint*)(arg0 + 40))), + containerId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 44)))), + shouldSelectSlot: (cast(uint)(*(cast(ubyte*)(arg0 + 45)))) != 0, + }; + auto _payload3492 = _record3160; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cPlayerHotbar(_payload3492); + break; + } + case _Tag3458.cPlayerList: { + auto _listSrcPtr3226 = *(cast(void**)(arg0 + (40+1*size_t.sizeof))); + auto _listLen3226 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _list3226 = _listLen3226 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.PlayerListEntry)(_listLen3226) : []; + assert(!_listLen3226 || _list3226.ptr); + if (_listLen3226) deallocate ~= cast(void*)_list3226.ptr; + foreach (_elem3162_idx, ref _elem3162; _list3226) { + const auto _base3162 = _listSrcPtr3226 + _elem3162_idx * (48+42*size_t.sizeof); + wit.pumpkin.plugin.uuid.common.Uuid _record3163 = { + high: *(cast(ulong*)(_base3162 + 0)), + low: *(cast(ulong*)(_base3162 + 8)), + }; + auto _len3164 = *(cast(size_t*)(_base3162 + (24+1*size_t.sizeof))); + auto _ptr3164 = _len3164 ? cast(char*)(*(cast(void**)(_base3162 + 24))) : null; + if (_len3164) deallocate ~= cast()_ptr3164; + auto _list3165 = WitString(_ptr3164[0.._len3164]); + auto _len3166 = *(cast(size_t*)(_base3162 + (24+3*size_t.sizeof))); + auto _ptr3166 = _len3166 ? cast(char*)(*(cast(void**)(_base3162 + (24+2*size_t.sizeof)))) : null; + if (_len3166) deallocate ~= cast()_ptr3166; + auto _list3167 = WitString(_ptr3166[0.._len3166]); + auto _len3168 = *(cast(size_t*)(_base3162 + (24+5*size_t.sizeof))); + auto _ptr3168 = _len3168 ? cast(char*)(*(cast(void**)(_base3162 + (24+4*size_t.sizeof)))) : null; + if (_len3168) deallocate ~= cast()_ptr3168; + auto _list3169 = WitString(_ptr3168[0.._len3168]); + auto _len3170 = *(cast(size_t*)(_base3162 + (24+8*size_t.sizeof))); + auto _ptr3170 = _len3170 ? cast(char*)(*(cast(void**)(_base3162 + (24+7*size_t.sizeof)))) : null; + if (_len3170) deallocate ~= cast()_ptr3170; + auto _list3171 = WitString(_ptr3170[0.._len3170]); + auto _len3172 = *(cast(size_t*)(_base3162 + (24+10*size_t.sizeof))); + auto _ptr3172 = _len3172 ? cast(char*)(*(cast(void**)(_base3162 + (24+9*size_t.sizeof)))) : null; + if (_len3172) deallocate ~= cast()_ptr3172; + auto _list3173 = WitString(_ptr3172[0.._len3172]); + auto _len3174 = *(cast(size_t*)(_base3162 + (24+12*size_t.sizeof))); + auto _ptr3174 = _len3174 ? cast(ubyte*)(*(cast(void**)(_base3162 + (24+11*size_t.sizeof)))) : null; + if (_len3174) deallocate ~= cast()_ptr3174; + auto _list3175 = WitList!(ubyte)(_ptr3174[0.._len3174]); + auto _len3176 = *(cast(size_t*)(_base3162 + (32+14*size_t.sizeof))); + auto _ptr3176 = _len3176 ? cast(ubyte*)(*(cast(void**)(_base3162 + (32+13*size_t.sizeof)))) : null; + if (_len3176) deallocate ~= cast()_ptr3176; + auto _list3177 = WitList!(ubyte)(_ptr3176[0.._len3176]); + auto _listSrcPtr3182 = *(cast(void**)(_base3162 + (32+15*size_t.sizeof))); + auto _listLen3182 = *(cast(size_t*)(_base3162 + (32+16*size_t.sizeof))); + auto _list3182 = _listLen3182 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.SkinAnimation)(_listLen3182) : []; + assert(!_listLen3182 || _list3182.ptr); + if (_listLen3182) deallocate ~= cast(void*)_list3182.ptr; + foreach (_elem3178_idx, ref _elem3178; _list3182) { + const auto _base3178 = _listSrcPtr3182 + _elem3178_idx * (24+2*size_t.sizeof); + auto _len3179 = *(cast(size_t*)(_base3178 + (8+1*size_t.sizeof))); + auto _ptr3179 = _len3179 ? cast(char*)(*(cast(void**)(_base3178 + 8))) : null; + if (_len3179) deallocate ~= cast()_ptr3179; + auto _list3180 = WitString(_ptr3179[0.._len3179]); + wit.pumpkin.plugin.bedrock_packets.common.SkinAnimation _record3181 = { + frames: *(cast(double*)(_base3178 + 0)), + image: _list3180, + imageHeight: cast(int)(*(cast(uint*)(_base3178 + (8+2*size_t.sizeof)))), + imageWidth: cast(int)(*(cast(uint*)(_base3178 + (12+2*size_t.sizeof)))), + animationType: cast(int)(*(cast(uint*)(_base3178 + (16+2*size_t.sizeof)))), + animationExpression: cast(int)(*(cast(uint*)(_base3178 + (20+2*size_t.sizeof)))), + }; + _elem3178 = _record3181; + } + if (_listLen3182) deallocate ~= _listSrcPtr3182; + auto _witList3183 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.SkinAnimation)(_list3182); + auto _len3184 = *(cast(size_t*)(_base3162 + (40+18*size_t.sizeof))); + auto _ptr3184 = _len3184 ? cast(ubyte*)(*(cast(void**)(_base3162 + (40+17*size_t.sizeof)))) : null; + if (_len3184) deallocate ~= cast()_ptr3184; + auto _list3185 = WitList!(ubyte)(_ptr3184[0.._len3184]); + auto _len3186 = *(cast(size_t*)(_base3162 + (40+20*size_t.sizeof))); + auto _ptr3186 = _len3186 ? cast(ubyte*)(*(cast(void**)(_base3162 + (40+19*size_t.sizeof)))) : null; + if (_len3186) deallocate ~= cast()_ptr3186; + auto _list3187 = WitList!(ubyte)(_ptr3186[0.._len3186]); + auto _len3188 = *(cast(size_t*)(_base3162 + (40+22*size_t.sizeof))); + auto _ptr3188 = _len3188 ? cast(ubyte*)(*(cast(void**)(_base3162 + (40+21*size_t.sizeof)))) : null; + if (_len3188) deallocate ~= cast()_ptr3188; + auto _list3189 = WitList!(ubyte)(_ptr3188[0.._len3188]); + auto _len3190 = *(cast(size_t*)(_base3162 + (40+24*size_t.sizeof))); + auto _ptr3190 = _len3190 ? cast(ubyte*)(*(cast(void**)(_base3162 + (40+23*size_t.sizeof)))) : null; + if (_len3190) deallocate ~= cast()_ptr3190; + auto _list3191 = WitList!(ubyte)(_ptr3190[0.._len3190]); + auto _len3192 = *(cast(size_t*)(_base3162 + (40+26*size_t.sizeof))); + auto _ptr3192 = _len3192 ? cast(char*)(*(cast(void**)(_base3162 + (40+25*size_t.sizeof)))) : null; + if (_len3192) deallocate ~= cast()_ptr3192; + auto _list3193 = WitString(_ptr3192[0.._len3192]); + auto _len3194 = *(cast(size_t*)(_base3162 + (40+28*size_t.sizeof))); + auto _ptr3194 = _len3194 ? cast(char*)(*(cast(void**)(_base3162 + (40+27*size_t.sizeof)))) : null; + if (_len3194) deallocate ~= cast()_ptr3194; + auto _list3195 = WitString(_ptr3194[0.._len3194]); + auto _len3196 = *(cast(size_t*)(_base3162 + (40+30*size_t.sizeof))); + auto _ptr3196 = _len3196 ? cast(char*)(*(cast(void**)(_base3162 + (40+29*size_t.sizeof)))) : null; + if (_len3196) deallocate ~= cast()_ptr3196; + auto _list3197 = WitString(_ptr3196[0.._len3196]); + auto _len3198 = *(cast(size_t*)(_base3162 + (40+32*size_t.sizeof))); + auto _ptr3198 = _len3198 ? cast(char*)(*(cast(void**)(_base3162 + (40+31*size_t.sizeof)))) : null; + if (_len3198) deallocate ~= cast()_ptr3198; + auto _list3199 = WitString(_ptr3198[0.._len3198]); + auto _listSrcPtr3210 = *(cast(void**)(_base3162 + (40+33*size_t.sizeof))); + auto _listLen3210 = *(cast(size_t*)(_base3162 + (40+34*size_t.sizeof))); + auto _list3210 = _listLen3210 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.PersonaPiece)(_listLen3210) : []; + assert(!_listLen3210 || _list3210.ptr); + if (_listLen3210) deallocate ~= cast(void*)_list3210.ptr; + foreach (_elem3200_idx, ref _elem3200; _list3210) { + const auto _base3200 = _listSrcPtr3210 + _elem3200_idx * (9*size_t.sizeof); + auto _len3201 = *(cast(size_t*)(_base3200 + (2*size_t.sizeof))); + auto _ptr3201 = _len3201 ? cast(char*)(*(cast(void**)(_base3200 + size_t.sizeof))) : null; + if (_len3201) deallocate ~= cast()_ptr3201; + auto _list3202 = WitString(_ptr3201[0.._len3201]); + auto _len3203 = *(cast(size_t*)(_base3200 + (4*size_t.sizeof))); + auto _ptr3203 = _len3203 ? cast(char*)(*(cast(void**)(_base3200 + (3*size_t.sizeof)))) : null; + if (_len3203) deallocate ~= cast()_ptr3203; + auto _list3204 = WitString(_ptr3203[0.._len3203]); + auto _len3205 = *(cast(size_t*)(_base3200 + (6*size_t.sizeof))); + auto _ptr3205 = _len3205 ? cast(char*)(*(cast(void**)(_base3200 + (5*size_t.sizeof)))) : null; + if (_len3205) deallocate ~= cast()_ptr3205; + auto _list3206 = WitString(_ptr3205[0.._len3205]); + auto _len3207 = *(cast(size_t*)(_base3200 + (8*size_t.sizeof))); + auto _ptr3207 = _len3207 ? cast(char*)(*(cast(void**)(_base3200 + (7*size_t.sizeof)))) : null; + if (_len3207) deallocate ~= cast()_ptr3207; + auto _list3208 = WitString(_ptr3207[0.._len3207]); + wit.pumpkin.plugin.bedrock_packets.common.PersonaPiece _record3209 = { + isDefault: (cast(uint)(*(cast(ubyte*)(_base3200 + 0)))) != 0, + packId: _list3202, + pieceId: _list3204, + pieceType: _list3206, + productId: _list3208, + }; + _elem3200 = _record3209; + } + if (_listLen3210) deallocate ~= _listSrcPtr3210; + auto _witList3211 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.PersonaPiece)(_list3210); + auto _listSrcPtr3218 = *(cast(void**)(_base3162 + (40+35*size_t.sizeof))); + auto _listLen3218 = *(cast(size_t*)(_base3162 + (40+36*size_t.sizeof))); + auto _list3218 = _listLen3218 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.PieceTintColor)(_listLen3218) : []; + assert(!_listLen3218 || _list3218.ptr); + if (_listLen3218) deallocate ~= cast(void*)_list3218.ptr; + foreach (_elem3212_idx, ref _elem3212; _list3218) { + const auto _base3212 = _listSrcPtr3218 + _elem3212_idx * (4*size_t.sizeof); + auto _len3213 = *(cast(size_t*)(_base3212 + size_t.sizeof)); + auto _ptr3213 = _len3213 ? cast(char*)(*(cast(void**)(_base3212 + 0))) : null; + if (_len3213) deallocate ~= cast()_ptr3213; + auto _list3214 = WitString(_ptr3213[0.._len3213]); + auto _len3215 = *(cast(size_t*)(_base3212 + (3*size_t.sizeof))); + auto _ptr3215 = _len3215 ? cast(int*)(*(cast(void**)(_base3212 + (2*size_t.sizeof)))) : null; + if (_len3215) deallocate ~= cast()_ptr3215; + auto _list3216 = WitList!(int)(_ptr3215[0.._len3215]); + wit.pumpkin.plugin.bedrock_packets.common.PieceTintColor _record3217 = { + pieceType: _list3214, + colors: _list3216, + }; + _elem3212 = _record3217; + } + if (_listLen3218) deallocate ~= _listSrcPtr3218; + auto _witList3219 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.PieceTintColor)(_list3218); + auto _len3220 = *(cast(size_t*)(_base3162 + (48+38*size_t.sizeof))); + auto _ptr3220 = _len3220 ? cast(char*)(*(cast(void**)(_base3162 + (48+37*size_t.sizeof)))) : null; + if (_len3220) deallocate ~= cast()_ptr3220; + auto _list3221 = WitString(_ptr3220[0.._len3220]); + wit.pumpkin.plugin.bedrock_packets.common.Skin _record3222 = { + skinId: _list3171, + playFabId: _list3173, + resourcePatch: _list3175, + imageWidth: cast(int)(*(cast(uint*)(_base3162 + (24+13*size_t.sizeof)))), + imageHeight: cast(int)(*(cast(uint*)(_base3162 + (28+13*size_t.sizeof)))), + skinData: _list3177, + animations: _witList3183, + capeWidth: cast(int)(*(cast(uint*)(_base3162 + (32+17*size_t.sizeof)))), + capeHeight: cast(int)(*(cast(uint*)(_base3162 + (36+17*size_t.sizeof)))), + capeData: _list3185, + geometryData: _list3187, + animationData: _list3189, + geometryDataEngineVersion: _list3191, + capeId: _list3193, + fullId: _list3195, + armSize: _list3197, + skinColor: _list3199, + personaPieces: _witList3211, + pieceTintColors: _witList3219, + isPremium: (cast(uint)(*(cast(ubyte*)(_base3162 + (40+37*size_t.sizeof))))) != 0, + isPersona: (cast(uint)(*(cast(ubyte*)(_base3162 + (41+37*size_t.sizeof))))) != 0, + personaCapeOnClassic: (cast(uint)(*(cast(ubyte*)(_base3162 + (42+37*size_t.sizeof))))) != 0, + isPrimaryUser: (cast(uint)(*(cast(ubyte*)(_base3162 + (43+37*size_t.sizeof))))) != 0, + overrideAppearance: (cast(uint)(*(cast(ubyte*)(_base3162 + (44+37*size_t.sizeof))))) != 0, + isTrusted: (cast(uint)(*(cast(ubyte*)(_base3162 + (45+37*size_t.sizeof))))) != 0, + profileHash: _list3221, + }; + auto _len3223 = *(cast(size_t*)(_base3162 + (48+41*size_t.sizeof))); + auto _ptr3223 = _len3223 ? cast(ubyte*)(*(cast(void**)(_base3162 + (48+40*size_t.sizeof)))) : null; + if (_len3223) deallocate ~= cast()_ptr3223; + auto _list3224 = WitList!(ubyte)(_ptr3223[0.._len3223]); + wit.pumpkin.plugin.bedrock_packets.common.PlayerListEntry _record3225 = { + uuid: _record3163, + entityUniqueId: cast(long)(*(cast(ulong*)(_base3162 + 16))), + username: _list3165, + xuid: _list3167, + platformChatId: _list3169, + buildPlatform: cast(wit.pumpkin.plugin.bedrock_packets.common.BuildPlatform)(cast(uint)(*(cast(ubyte*)(_base3162 + (24+6*size_t.sizeof))))), + skin: _record3222, + isTeacher: (cast(uint)(*(cast(ubyte*)(_base3162 + (48+39*size_t.sizeof))))) != 0, + isHost: (cast(uint)(*(cast(ubyte*)(_base3162 + (49+39*size_t.sizeof))))) != 0, + isSubClient: (cast(uint)(*(cast(ubyte*)(_base3162 + (50+39*size_t.sizeof))))) != 0, + playerColor: _list3224, + }; + _elem3162 = _record3225; + } + if (_listLen3226) deallocate ~= _listSrcPtr3226; + auto _witList3227 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.PlayerListEntry)(_list3226); + wit.pumpkin.plugin.bedrock_packets.common.CPlayerList _record3228 = { + action: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 40)))), + entries: _witList3227, + }; + auto _payload3493 = _record3228; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cPlayerList(_payload3493); + break; + } + case _Tag3458.cRemoveActor: { + wit.pumpkin.plugin.bedrock_packets.common.CRemoveActor _record3230 = { + targetActorId: cast(long)(*(cast(ulong*)(arg0 + 40))), + }; + auto _payload3494 = _record3230; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cRemoveActor(_payload3494); + break; + } + case _Tag3458.cRemoveObjective: { + auto _len3232 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr3232 = _len3232 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len3232) deallocate ~= cast()_ptr3232; + auto _list3233 = WitString(_ptr3232[0.._len3232]); + wit.pumpkin.plugin.bedrock_packets.common.CRemoveObjective _record3234 = { + objectiveName: _list3233, + }; + auto _payload3495 = _record3234; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cRemoveObjective(_payload3495); + break; + } + case _Tag3458.cResourcePackStackPacket: { + auto _listSrcPtr3244 = *(cast(void**)(arg0 + (40+1*size_t.sizeof))); + auto _listLen3244 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _list3244 = _listLen3244 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.PackInstanceId)(_listLen3244) : []; + assert(!_listLen3244 || _list3244.ptr); + if (_listLen3244) deallocate ~= cast(void*)_list3244.ptr; + foreach (_elem3236_idx, ref _elem3236; _list3244) { + const auto _base3236 = _listSrcPtr3244 + _elem3236_idx * (6*size_t.sizeof); + auto _len3237 = *(cast(size_t*)(_base3236 + size_t.sizeof)); + auto _ptr3237 = _len3237 ? cast(char*)(*(cast(void**)(_base3236 + 0))) : null; + if (_len3237) deallocate ~= cast()_ptr3237; + auto _list3238 = WitString(_ptr3237[0.._len3237]); + auto _len3239 = *(cast(size_t*)(_base3236 + (3*size_t.sizeof))); + auto _ptr3239 = _len3239 ? cast(char*)(*(cast(void**)(_base3236 + (2*size_t.sizeof)))) : null; + if (_len3239) deallocate ~= cast()_ptr3239; + auto _list3240 = WitString(_ptr3239[0.._len3239]); + auto _len3241 = *(cast(size_t*)(_base3236 + (5*size_t.sizeof))); + auto _ptr3241 = _len3241 ? cast(char*)(*(cast(void**)(_base3236 + (4*size_t.sizeof)))) : null; + if (_len3241) deallocate ~= cast()_ptr3241; + auto _list3242 = WitString(_ptr3241[0.._len3241]); + wit.pumpkin.plugin.bedrock_packets.common.PackInstanceId _record3243 = { + packId: _list3238, + version_: _list3240, + subPackName: _list3242, + }; + _elem3236 = _record3243; + } + if (_listLen3244) deallocate ~= _listSrcPtr3244; + auto _witList3245 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.PackInstanceId)(_list3244); + auto _len3246 = *(cast(size_t*)(arg0 + (40+4*size_t.sizeof))); + auto _ptr3246 = _len3246 ? cast(char*)(*(cast(void**)(arg0 + (40+3*size_t.sizeof)))) : null; + if (_len3246) deallocate ~= cast()_ptr3246; + auto _list3247 = WitString(_ptr3246[0.._len3246]); + auto _listSrcPtr3252 = *(cast(void**)(arg0 + (40+5*size_t.sizeof))); + auto _listLen3252 = *(cast(size_t*)(arg0 + (40+6*size_t.sizeof))); + auto _list3252 = _listLen3252 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.ExperimentToggle)(_listLen3252) : []; + assert(!_listLen3252 || _list3252.ptr); + if (_listLen3252) deallocate ~= cast(void*)_list3252.ptr; + foreach (_elem3248_idx, ref _elem3248; _list3252) { + const auto _base3248 = _listSrcPtr3252 + _elem3248_idx * (3*size_t.sizeof); + auto _len3249 = *(cast(size_t*)(_base3248 + size_t.sizeof)); + auto _ptr3249 = _len3249 ? cast(char*)(*(cast(void**)(_base3248 + 0))) : null; + if (_len3249) deallocate ~= cast()_ptr3249; + auto _list3250 = WitString(_ptr3249[0.._len3249]); + wit.pumpkin.plugin.bedrock_packets.common.ExperimentToggle _record3251 = { + name: _list3250, + enabled: (cast(uint)(*(cast(ubyte*)(_base3248 + (2*size_t.sizeof))))) != 0, + }; + _elem3248 = _record3251; + } + if (_listLen3252) deallocate ~= _listSrcPtr3252; + auto _witList3253 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.ExperimentToggle)(_list3252); + wit.pumpkin.plugin.bedrock_packets.common.Experiments _record3254 = { + toggles: _witList3253, + experimentsEverToggled: (cast(uint)(*(cast(ubyte*)(arg0 + (40+7*size_t.sizeof))))) != 0, + }; + wit.pumpkin.plugin.bedrock_packets.common.CResourcePackStackPacket _record3255 = { + texturePackRequired: (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0, + texturePackList: _witList3245, + baseGameVersion: _list3247, + experiments: _record3254, + includeEditorPacks: (cast(uint)(*(cast(ubyte*)(arg0 + (40+8*size_t.sizeof))))) != 0, + }; + auto _payload3496 = _record3255; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cResourcePackStackPacket(_payload3496); + break; + } + case _Tag3458.cResourcePacksInfo: { + wit.pumpkin.plugin.uuid.common.Uuid _record3257 = { + high: *(cast(ulong*)(arg0 + 48)), + low: *(cast(ulong*)(arg0 + 56)), + }; + auto _len3258 = *(cast(size_t*)(arg0 + (64+1*size_t.sizeof))); + auto _ptr3258 = _len3258 ? cast(char*)(*(cast(void**)(arg0 + 64))) : null; + if (_len3258) deallocate ~= cast()_ptr3258; + auto _list3259 = WitString(_ptr3258[0.._len3258]); + wit.pumpkin.plugin.bedrock_packets.common.PackIdVersion _record3260 = { + packUuid: _record3257, + packVersion: _list3259, + }; + auto _listSrcPtr3275 = *(cast(void**)(arg0 + (64+2*size_t.sizeof))); + auto _listLen3275 = *(cast(size_t*)(arg0 + (64+3*size_t.sizeof))); + auto _list3275 = _listLen3275 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.PackInfoData)(_listLen3275) : []; + assert(!_listLen3275 || _list3275.ptr); + if (_listLen3275) deallocate ~= cast(void*)_list3275.ptr; + foreach (_elem3261_idx, ref _elem3261; _list3275) { + const auto _base3261 = _listSrcPtr3275 + _elem3261_idx * (32+10*size_t.sizeof); + wit.pumpkin.plugin.uuid.common.Uuid _record3262 = { + high: *(cast(ulong*)(_base3261 + 0)), + low: *(cast(ulong*)(_base3261 + 8)), + }; + auto _len3263 = *(cast(size_t*)(_base3261 + (16+1*size_t.sizeof))); + auto _ptr3263 = _len3263 ? cast(char*)(*(cast(void**)(_base3261 + 16))) : null; + if (_len3263) deallocate ~= cast()_ptr3263; + auto _list3264 = WitString(_ptr3263[0.._len3263]); + wit.pumpkin.plugin.bedrock_packets.common.PackIdVersion _record3265 = { + packUuid: _record3262, + packVersion: _list3264, + }; + auto _len3266 = *(cast(size_t*)(_base3261 + (24+3*size_t.sizeof))); + auto _ptr3266 = _len3266 ? cast(char*)(*(cast(void**)(_base3261 + (24+2*size_t.sizeof)))) : null; + if (_len3266) deallocate ~= cast()_ptr3266; + auto _list3267 = WitString(_ptr3266[0.._len3266]); + auto _len3268 = *(cast(size_t*)(_base3261 + (24+5*size_t.sizeof))); + auto _ptr3268 = _len3268 ? cast(char*)(*(cast(void**)(_base3261 + (24+4*size_t.sizeof)))) : null; + if (_len3268) deallocate ~= cast()_ptr3268; + auto _list3269 = WitString(_ptr3268[0.._len3268]); + auto _len3270 = *(cast(size_t*)(_base3261 + (24+7*size_t.sizeof))); + auto _ptr3270 = _len3270 ? cast(char*)(*(cast(void**)(_base3261 + (24+6*size_t.sizeof)))) : null; + if (_len3270) deallocate ~= cast()_ptr3270; + auto _list3271 = WitString(_ptr3270[0.._len3270]); + auto _len3272 = *(cast(size_t*)(_base3261 + (24+10*size_t.sizeof))); + auto _ptr3272 = _len3272 ? cast(char*)(*(cast(void**)(_base3261 + (24+9*size_t.sizeof)))) : null; + if (_len3272) deallocate ~= cast()_ptr3272; + auto _list3273 = WitString(_ptr3272[0.._len3272]); + wit.pumpkin.plugin.bedrock_packets.common.PackInfoData _record3274 = { + packIdVersion: _record3265, + packSize: cast(long)(*(cast(ulong*)(_base3261 + (16+2*size_t.sizeof)))), + contentKey: _list3267, + subpackName: _list3269, + contentIdentity: _list3271, + hasScripts: (cast(uint)(*(cast(ubyte*)(_base3261 + (24+8*size_t.sizeof))))) != 0, + isAddonPack: (cast(uint)(*(cast(ubyte*)(_base3261 + (25+8*size_t.sizeof))))) != 0, + isRayTracingCapable: (cast(uint)(*(cast(ubyte*)(_base3261 + (26+8*size_t.sizeof))))) != 0, + cdnUrl: _list3273, + }; + _elem3261 = _record3274; + } + if (_listLen3275) deallocate ~= _listSrcPtr3275; + auto _witList3276 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.PackInfoData)(_list3275); + wit.pumpkin.plugin.bedrock_packets.common.CResourcePacksInfo _record3277 = { + resourcePackRequired: (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0, + hasAddonPacks: (cast(uint)(*(cast(ubyte*)(arg0 + 41)))) != 0, + hasScripts: (cast(uint)(*(cast(ubyte*)(arg0 + 42)))) != 0, + forceDisableVibrantVisuals: (cast(uint)(*(cast(ubyte*)(arg0 + 43)))) != 0, + worldTemplateIdAndVersion: _record3260, + resourcePacks: _witList3276, + }; + auto _payload3497 = _record3277; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cResourcePacksInfo(_payload3497); + break; + } + case _Tag3458.cSetActorData: { + auto _len3279 = *(cast(size_t*)(arg0 + (48+1*size_t.sizeof))); + auto _ptr3279 = _len3279 ? cast(char*)(*(cast(void**)(arg0 + 48))) : null; + if (_len3279) deallocate ~= cast()_ptr3279; + auto _list3280 = WitString(_ptr3279[0.._len3279]); + auto _len3281 = *(cast(size_t*)(arg0 + (48+3*size_t.sizeof))); + auto _ptr3281 = _len3281 ? cast(Tuple!(int, int)*)(*(cast(void**)(arg0 + (48+2*size_t.sizeof)))) : null; + if (_len3281) deallocate ~= cast()_ptr3281; + auto _list3282 = WitList!(Tuple!(int, int))(_ptr3281[0.._len3281]); + auto _len3283 = *(cast(size_t*)(arg0 + (48+5*size_t.sizeof))); + auto _ptr3283 = _len3283 ? cast(Tuple!(int, float)*)(*(cast(void**)(arg0 + (48+4*size_t.sizeof)))) : null; + if (_len3283) deallocate ~= cast()_ptr3283; + auto _list3284 = WitList!(Tuple!(int, float))(_ptr3283[0.._len3283]); + wit.pumpkin.plugin.bedrock_packets.common.PropertySyncData _record3285 = { + intEntriesList: _list3282, + floatEntriesList: _list3284, + }; + wit.pumpkin.plugin.bedrock_packets.common.CSetActorData _record3286 = { + targetRuntimeId: cast(long)(*(cast(ulong*)(arg0 + 40))), + actorData: _list3280, + syncedProperties: _record3285, + tick: cast(long)(*(cast(ulong*)(arg0 + (48+6*size_t.sizeof)))), + }; + auto _payload3498 = _record3286; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cSetActorData(_payload3498); + break; + } + case _Tag3458.cSetActorLink: { + wit.pumpkin.plugin.bedrock_packets.common.ActorLink _record3288 = { + riddenUniqueId: cast(long)(*(cast(ulong*)(arg0 + 40))), + riderUniqueId: cast(long)(*(cast(ulong*)(arg0 + 48))), + linkType: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 56)))), + immediate: (cast(uint)(*(cast(ubyte*)(arg0 + 57)))) != 0, + riderInitiated: (cast(uint)(*(cast(ubyte*)(arg0 + 58)))) != 0, + vehicleAngularVelocity: *(cast(float*)(arg0 + 60)), + }; + wit.pumpkin.plugin.bedrock_packets.common.CSetActorLink _record3289 = { + link: _record3288, + }; + auto _payload3499 = _record3289; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cSetActorLink(_payload3499); + break; + } + case _Tag3458.cSetActorMotion: { + auto _tuple3291 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 48)), + *(cast(double*)(arg0 + 56)), + *(cast(double*)(arg0 + 64)), + ); + wit.pumpkin.plugin.bedrock_packets.common.CSetActorMotion _record3292 = { + targetRuntimeId: cast(long)(*(cast(ulong*)(arg0 + 40))), + motion: _tuple3291, + tick: cast(long)(*(cast(ulong*)(arg0 + 72))), + }; + auto _payload3500 = _record3292; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cSetActorMotion(_payload3500); + break; + } + case _Tag3458.cSetDifficulty: { + wit.pumpkin.plugin.bedrock_packets.common.CSetDifficulty _record3294 = { + difficulty: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload3501 = _record3294; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cSetDifficulty(_payload3501); + break; + } + case _Tag3458.cSetDisplayObjective: { + auto _len3296 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr3296 = _len3296 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len3296) deallocate ~= cast()_ptr3296; + auto _list3297 = WitString(_ptr3296[0.._len3296]); + auto _len3298 = *(cast(size_t*)(arg0 + (40+3*size_t.sizeof))); + auto _ptr3298 = _len3298 ? cast(char*)(*(cast(void**)(arg0 + (40+2*size_t.sizeof)))) : null; + if (_len3298) deallocate ~= cast()_ptr3298; + auto _list3299 = WitString(_ptr3298[0.._len3298]); + auto _len3300 = *(cast(size_t*)(arg0 + (40+5*size_t.sizeof))); + auto _ptr3300 = _len3300 ? cast(char*)(*(cast(void**)(arg0 + (40+4*size_t.sizeof)))) : null; + if (_len3300) deallocate ~= cast()_ptr3300; + auto _list3301 = WitString(_ptr3300[0.._len3300]); + auto _len3302 = *(cast(size_t*)(arg0 + (40+7*size_t.sizeof))); + auto _ptr3302 = _len3302 ? cast(char*)(*(cast(void**)(arg0 + (40+6*size_t.sizeof)))) : null; + if (_len3302) deallocate ~= cast()_ptr3302; + auto _list3303 = WitString(_ptr3302[0.._len3302]); + wit.pumpkin.plugin.bedrock_packets.common.CSetDisplayObjective _record3304 = { + displaySlotName: _list3297, + objectiveName: _list3299, + objectiveDisplayName: _list3301, + criteriaName: _list3303, + sortOrder: cast(int)(*(cast(uint*)(arg0 + (40+8*size_t.sizeof)))), + }; + auto _payload3502 = _record3304; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cSetDisplayObjective(_payload3502); + break; + } + case _Tag3458.cSetHealth: { + wit.pumpkin.plugin.bedrock_packets.common.CSetHealth _record3306 = { + health: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload3503 = _record3306; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cSetHealth(_payload3503); + break; + } + case _Tag3458.cSetPlayerGameType: { + wit.pumpkin.plugin.bedrock_packets.common.CSetPlayerGameType _record3308 = { + playerGameType: cast(wit.pumpkin.plugin.bedrock_packets.common.GameType)(cast(uint)(*(cast(ubyte*)(arg0 + 40)))), + }; + auto _payload3504 = _record3308; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cSetPlayerGameType(_payload3504); + break; + } + case _Tag3458.cSetScore: { + auto _listSrcPtr3316 = *(cast(void**)(arg0 + (40+1*size_t.sizeof))); + auto _listLen3316 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _list3316 = _listLen3316 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.ScoreEntry)(_listLen3316) : []; + assert(!_listLen3316 || _list3316.ptr); + if (_listLen3316) deallocate ~= cast(void*)_list3316.ptr; + foreach (_elem3310_idx, ref _elem3310; _list3316) { + const auto _base3310 = _listSrcPtr3316 + _elem3310_idx * (24+4*size_t.sizeof); + auto _len3311 = *(cast(size_t*)(_base3310 + (8+1*size_t.sizeof))); + auto _ptr3311 = _len3311 ? cast(char*)(*(cast(void**)(_base3310 + 8))) : null; + if (_len3311) deallocate ~= cast()_ptr3311; + auto _list3312 = WitString(_ptr3311[0.._len3311]); + auto _len3313 = *(cast(size_t*)(_base3310 + (24+3*size_t.sizeof))); + auto _ptr3313 = _len3313 ? cast(char*)(*(cast(void**)(_base3310 + (24+2*size_t.sizeof)))) : null; + if (_len3313) deallocate ~= cast()_ptr3313; + auto _list3314 = WitString(_ptr3313[0.._len3313]); + wit.pumpkin.plugin.bedrock_packets.common.ScoreEntry _record3315 = { + scoreboardId: cast(long)(*(cast(ulong*)(_base3310 + 0))), + objectiveName: _list3312, + score: cast(int)(*(cast(uint*)(_base3310 + (8+2*size_t.sizeof)))), + entryType: cast(int)(*(cast(uint*)(_base3310 + (12+2*size_t.sizeof)))), + entityUniqueId: cast(long)(*(cast(ulong*)(_base3310 + (16+2*size_t.sizeof)))), + customName: _list3314, + }; + _elem3310 = _record3315; + } + if (_listLen3316) deallocate ~= _listSrcPtr3316; + auto _witList3317 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.ScoreEntry)(_list3316); + wit.pumpkin.plugin.bedrock_packets.common.CSetScore _record3318 = { + action: cast(int)(*(cast(uint*)(arg0 + 40))), + entries: _witList3317, + }; + auto _payload3505 = _record3318; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cSetScore(_payload3505); + break; + } + case _Tag3458.cSetSpawnPosition: { + auto _tuple3320 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + cast(int)(*(cast(uint*)(arg0 + 52))), + ); + auto _tuple3321 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 60))), + cast(int)(*(cast(uint*)(arg0 + 64))), + cast(int)(*(cast(uint*)(arg0 + 68))), + ); + wit.pumpkin.plugin.bedrock_packets.common.CSetSpawnPosition _record3322 = { + spawnPositionType: cast(wit.pumpkin.plugin.bedrock_packets.common.SpawnPositionType)(cast(uint)(*(cast(ubyte*)(arg0 + 40)))), + blockPosition: _tuple3320, + dimensionType: cast(int)(*(cast(uint*)(arg0 + 56))), + spawnBlockPos: _tuple3321, + }; + auto _payload3506 = _record3322; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cSetSpawnPosition(_payload3506); + break; + } + case _Tag3458.cSetTime: { + wit.pumpkin.plugin.bedrock_packets.common.CSetTime _record3324 = { + time: cast(int)(*(cast(uint*)(arg0 + 40))), + }; + auto _payload3507 = _record3324; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cSetTime(_payload3507); + break; + } + case _Tag3458.cSetTitle: { + auto _len3326 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _ptr3326 = _len3326 ? cast(char*)(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))) : null; + if (_len3326) deallocate ~= cast()_ptr3326; + auto _list3327 = WitString(_ptr3326[0.._len3326]); + auto _len3328 = *(cast(size_t*)(arg0 + (48+5*size_t.sizeof))); + auto _ptr3328 = _len3328 ? cast(char*)(*(cast(void**)(arg0 + (48+4*size_t.sizeof)))) : null; + if (_len3328) deallocate ~= cast()_ptr3328; + auto _list3329 = WitString(_ptr3328[0.._len3328]); + auto _len3330 = *(cast(size_t*)(arg0 + (48+7*size_t.sizeof))); + auto _ptr3330 = _len3330 ? cast(char*)(*(cast(void**)(arg0 + (48+6*size_t.sizeof)))) : null; + if (_len3330) deallocate ~= cast()_ptr3330; + auto _list3331 = WitString(_ptr3330[0.._len3330]); + auto _len3332 = *(cast(size_t*)(arg0 + (48+9*size_t.sizeof))); + auto _ptr3332 = _len3332 ? cast(char*)(*(cast(void**)(arg0 + (48+8*size_t.sizeof)))) : null; + if (_len3332) deallocate ~= cast()_ptr3332; + auto _list3333 = WitString(_ptr3332[0.._len3332]); + wit.pumpkin.plugin.bedrock_packets.common.CSetTitle _record3334 = { + titleType: cast(wit.pumpkin.plugin.bedrock_packets.common.TitleType)(cast(uint)(*(cast(ubyte*)(arg0 + 40)))), + titleText: _list3327, + fadeInTime: cast(int)(*(cast(uint*)(arg0 + (40+3*size_t.sizeof)))), + stayTime: cast(int)(*(cast(uint*)(arg0 + (44+3*size_t.sizeof)))), + fadeOutTime: cast(int)(*(cast(uint*)(arg0 + (48+3*size_t.sizeof)))), + xuid: _list3329, + platformOnlineId: _list3331, + filteredTitleMessage: _list3333, + }; + auto _payload3508 = _record3334; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cSetTitle(_payload3508); + break; + } + case _Tag3458.cShowCredits: { + wit.pumpkin.plugin.bedrock_packets.common.CShowCredits _record3336 = { + playerRuntimeId: cast(long)(*(cast(ulong*)(arg0 + 40))), + creditsState: cast(int)(*(cast(uint*)(arg0 + 48))), + }; + auto _payload3509 = _record3336; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cShowCredits(_payload3509); + break; + } + case _Tag3458.cStartGame: { + auto _tuple3338 = Tuple!(double, double, double)( + *(cast(double*)(arg0 + 64)), + *(cast(double*)(arg0 + 72)), + *(cast(double*)(arg0 + 80)), + ); + auto _len3339 = *(cast(size_t*)(arg0 + (104+2*size_t.sizeof))); + auto _ptr3339 = _len3339 ? cast(char*)(*(cast(void**)(arg0 + (104+1*size_t.sizeof)))) : null; + if (_len3339) deallocate ~= cast()_ptr3339; + auto _list3340 = WitString(_ptr3339[0.._len3339]); + auto _tuple3341 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + (120+3*size_t.sizeof)))), + cast(int)(*(cast(uint*)(arg0 + (124+3*size_t.sizeof)))), + cast(int)(*(cast(uint*)(arg0 + (128+3*size_t.sizeof)))), + ); + auto _len3342 = *(cast(size_t*)(arg0 + (152+5*size_t.sizeof))); + auto _ptr3342 = _len3342 ? cast(char*)(*(cast(void**)(arg0 + (152+4*size_t.sizeof)))) : null; + if (_len3342) deallocate ~= cast()_ptr3342; + auto _list3343 = WitString(_ptr3342[0.._len3342]); + auto _listSrcPtr3348 = *(cast(void**)(arg0 + (168+6*size_t.sizeof))); + auto _listLen3348 = *(cast(size_t*)(arg0 + (168+7*size_t.sizeof))); + auto _list3348 = _listLen3348 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.GameRule)(_listLen3348) : []; + assert(!_listLen3348 || _list3348.ptr); + if (_listLen3348) deallocate ~= cast(void*)_list3348.ptr; + foreach (_elem3344_idx, ref _elem3344; _list3348) { + const auto _base3344 = _listSrcPtr3348 + _elem3344_idx * (3*size_t.sizeof); + auto _len3345 = *(cast(size_t*)(_base3344 + size_t.sizeof)); + auto _ptr3345 = _len3345 ? cast(char*)(*(cast(void**)(_base3344 + 0))) : null; + if (_len3345) deallocate ~= cast()_ptr3345; + auto _list3346 = WitString(_ptr3345[0.._len3345]); + wit.pumpkin.plugin.bedrock_packets.common.GameRule _record3347 = { + ruleName: _list3346, + ruleCanBeModified: (cast(uint)(*(cast(ubyte*)(_base3344 + (2*size_t.sizeof))))) != 0, + ruleValue: cast(wit.pumpkin.plugin.bedrock_packets.common.RuleValue)(cast(uint)(*(cast(ubyte*)(_base3344 + (1+2*size_t.sizeof))))), + }; + _elem3344 = _record3347; + } + if (_listLen3348) deallocate ~= _listSrcPtr3348; + auto _witList3349 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.GameRule)(_list3348); + auto _listSrcPtr3354 = *(cast(void**)(arg0 + (168+8*size_t.sizeof))); + auto _listLen3354 = *(cast(size_t*)(arg0 + (168+9*size_t.sizeof))); + auto _list3354 = _listLen3354 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.ExperimentToggle)(_listLen3354) : []; + assert(!_listLen3354 || _list3354.ptr); + if (_listLen3354) deallocate ~= cast(void*)_list3354.ptr; + foreach (_elem3350_idx, ref _elem3350; _list3354) { + const auto _base3350 = _listSrcPtr3354 + _elem3350_idx * (3*size_t.sizeof); + auto _len3351 = *(cast(size_t*)(_base3350 + size_t.sizeof)); + auto _ptr3351 = _len3351 ? cast(char*)(*(cast(void**)(_base3350 + 0))) : null; + if (_len3351) deallocate ~= cast()_ptr3351; + auto _list3352 = WitString(_ptr3351[0.._len3351]); + wit.pumpkin.plugin.bedrock_packets.common.ExperimentToggle _record3353 = { + name: _list3352, + enabled: (cast(uint)(*(cast(ubyte*)(_base3350 + (2*size_t.sizeof))))) != 0, + }; + _elem3350 = _record3353; + } + if (_listLen3354) deallocate ~= _listSrcPtr3354; + auto _witList3355 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.ExperimentToggle)(_list3354); + wit.pumpkin.plugin.bedrock_packets.common.Experiments _record3356 = { + toggles: _witList3355, + experimentsEverToggled: (cast(uint)(*(cast(ubyte*)(arg0 + (168+10*size_t.sizeof))))) != 0, + }; + auto _len3357 = *(cast(size_t*)(arg0 + (184+13*size_t.sizeof))); + auto _ptr3357 = _len3357 ? cast(char*)(*(cast(void**)(arg0 + (184+12*size_t.sizeof)))) : null; + if (_len3357) deallocate ~= cast()_ptr3357; + auto _list3358 = WitString(_ptr3357[0.._len3357]); + auto _len3359 = *(cast(size_t*)(arg0 + (192+16*size_t.sizeof))); + auto _ptr3359 = _len3359 ? cast(char*)(*(cast(void**)(arg0 + (192+15*size_t.sizeof)))) : null; + if (_len3359) deallocate ~= cast()_ptr3359; + auto _list3360 = WitString(_ptr3359[0.._len3359]); + auto _len3361 = *(cast(size_t*)(arg0 + (192+18*size_t.sizeof))); + auto _ptr3361 = _len3361 ? cast(char*)(*(cast(void**)(arg0 + (192+17*size_t.sizeof)))) : null; + if (_len3361) deallocate ~= cast()_ptr3361; + auto _list3362 = WitString(_ptr3361[0.._len3361]); + wit.pumpkin.plugin.bedrock_packets.common.LevelSettings _record3363 = { + seed: cast(long)(*(cast(ulong*)(arg0 + 96))), + spawnBiomeType: cast(int)(*(cast(uint*)(arg0 + 104))), + customBiomeName: _list3340, + dimension: cast(int)(*(cast(uint*)(arg0 + (104+3*size_t.sizeof)))), + generatorType: cast(int)(*(cast(uint*)(arg0 + (108+3*size_t.sizeof)))), + worldGamemode: cast(wit.pumpkin.plugin.bedrock_packets.common.GameType)(cast(uint)(*(cast(ubyte*)(arg0 + (112+3*size_t.sizeof))))), + hardcore: (cast(uint)(*(cast(ubyte*)(arg0 + (113+3*size_t.sizeof))))) != 0, + difficulty: cast(int)(*(cast(uint*)(arg0 + (116+3*size_t.sizeof)))), + spawnPosition: _tuple3341, + hasAchievementsDisabled: (cast(uint)(*(cast(ubyte*)(arg0 + (132+3*size_t.sizeof))))) != 0, + editorWorldType: cast(int)(*(cast(uint*)(arg0 + (136+3*size_t.sizeof)))), + isCreatedInEditor: (cast(uint)(*(cast(ubyte*)(arg0 + (140+3*size_t.sizeof))))) != 0, + isExportedFromEditor: (cast(uint)(*(cast(ubyte*)(arg0 + (141+3*size_t.sizeof))))) != 0, + dayCycleStopTime: cast(int)(*(cast(uint*)(arg0 + (144+3*size_t.sizeof)))), + educationEditionOffer: cast(int)(*(cast(uint*)(arg0 + (148+3*size_t.sizeof)))), + hasEducationFeaturesEnabled: (cast(uint)(*(cast(ubyte*)(arg0 + (152+3*size_t.sizeof))))) != 0, + educationProductId: _list3343, + rainLevel: *(cast(float*)(arg0 + (152+6*size_t.sizeof))), + lightningLevel: *(cast(float*)(arg0 + (156+6*size_t.sizeof))), + hasConfirmedPlatformLockedContent: (cast(uint)(*(cast(ubyte*)(arg0 + (160+6*size_t.sizeof))))) != 0, + wasMultiplayerIntended: (cast(uint)(*(cast(ubyte*)(arg0 + (161+6*size_t.sizeof))))) != 0, + wasLanBroadcastingIntended: (cast(uint)(*(cast(ubyte*)(arg0 + (162+6*size_t.sizeof))))) != 0, + xboxLiveBroadcastSetting: cast(wit.pumpkin.plugin.bedrock_packets.common.GamePublishSetting)(cast(uint)(*(cast(ubyte*)(arg0 + (163+6*size_t.sizeof))))), + platformBroadcastSetting: cast(wit.pumpkin.plugin.bedrock_packets.common.GamePublishSetting)(cast(uint)(*(cast(ubyte*)(arg0 + (164+6*size_t.sizeof))))), + commandsEnabled: (cast(uint)(*(cast(ubyte*)(arg0 + (165+6*size_t.sizeof))))) != 0, + isTexturePacksRequired: (cast(uint)(*(cast(ubyte*)(arg0 + (166+6*size_t.sizeof))))) != 0, + ruleData: _witList3349, + experiments: _record3356, + bonusChest: (cast(uint)(*(cast(ubyte*)(arg0 + (168+11*size_t.sizeof))))) != 0, + hasStartWithMapEnabled: (cast(uint)(*(cast(ubyte*)(arg0 + (169+11*size_t.sizeof))))) != 0, + permissionLevel: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (170+11*size_t.sizeof))))), + serverSimulationDistance: cast(int)(*(cast(uint*)(arg0 + (172+11*size_t.sizeof)))), + hasLockedBehaviorPack: (cast(uint)(*(cast(ubyte*)(arg0 + (176+11*size_t.sizeof))))) != 0, + hasLockedResourcePack: (cast(uint)(*(cast(ubyte*)(arg0 + (177+11*size_t.sizeof))))) != 0, + isFromLockedWorldTemplate: (cast(uint)(*(cast(ubyte*)(arg0 + (178+11*size_t.sizeof))))) != 0, + isUsingMsaGamertagsOnly: (cast(uint)(*(cast(ubyte*)(arg0 + (179+11*size_t.sizeof))))) != 0, + isFromWorldTemplate: (cast(uint)(*(cast(ubyte*)(arg0 + (180+11*size_t.sizeof))))) != 0, + isWorldTemplateOptionLocked: (cast(uint)(*(cast(ubyte*)(arg0 + (181+11*size_t.sizeof))))) != 0, + isOnlySpawningV1Villagers: (cast(uint)(*(cast(ubyte*)(arg0 + (182+11*size_t.sizeof))))) != 0, + isDisablingPersonas: (cast(uint)(*(cast(ubyte*)(arg0 + (183+11*size_t.sizeof))))) != 0, + isDisablingCustomSkins: (cast(uint)(*(cast(ubyte*)(arg0 + (184+11*size_t.sizeof))))) != 0, + emoteChatMuted: (cast(uint)(*(cast(ubyte*)(arg0 + (185+11*size_t.sizeof))))) != 0, + gameVersion: _list3358, + limitedWorldWidth: cast(int)(*(cast(uint*)(arg0 + (184+14*size_t.sizeof)))), + limitedWorldHeight: cast(int)(*(cast(uint*)(arg0 + (188+14*size_t.sizeof)))), + newNether: (cast(uint)(*(cast(ubyte*)(arg0 + (192+14*size_t.sizeof))))) != 0, + eduSharedUriButtonName: _list3360, + eduSharedUriLinkUri: _list3362, + overrideForceExperimentalGameplayHasValue: (cast(uint)(*(cast(ubyte*)(arg0 + (192+19*size_t.sizeof))))) != 0, + chatRestrictionLevel: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (193+19*size_t.sizeof))))), + disablePlayerInteractions: (cast(uint)(*(cast(ubyte*)(arg0 + (194+19*size_t.sizeof))))) != 0, + serverEditorConnectionPolicy: cast(int)(*(cast(uint*)(arg0 + (196+19*size_t.sizeof)))), + allowAnonymousBlockDropsInEditorWorlds: (cast(uint)(*(cast(ubyte*)(arg0 + (200+19*size_t.sizeof))))) != 0, + }; + auto _len3364 = *(cast(size_t*)(arg0 + (200+21*size_t.sizeof))); + auto _ptr3364 = _len3364 ? cast(char*)(*(cast(void**)(arg0 + (200+20*size_t.sizeof)))) : null; + if (_len3364) deallocate ~= cast()_ptr3364; + auto _list3365 = WitString(_ptr3364[0.._len3364]); + auto _len3366 = *(cast(size_t*)(arg0 + (200+23*size_t.sizeof))); + auto _ptr3366 = _len3366 ? cast(char*)(*(cast(void**)(arg0 + (200+22*size_t.sizeof)))) : null; + if (_len3366) deallocate ~= cast()_ptr3366; + auto _list3367 = WitString(_ptr3366[0.._len3366]); + auto _len3368 = *(cast(size_t*)(arg0 + (200+25*size_t.sizeof))); + auto _ptr3368 = _len3368 ? cast(char*)(*(cast(void**)(arg0 + (200+24*size_t.sizeof)))) : null; + if (_len3368) deallocate ~= cast()_ptr3368; + auto _list3369 = WitString(_ptr3368[0.._len3368]); + auto _len3370 = *(cast(size_t*)(arg0 + (232+27*size_t.sizeof))); + auto _ptr3370 = _len3370 ? cast(char*)(*(cast(void**)(arg0 + (232+26*size_t.sizeof)))) : null; + if (_len3370) deallocate ~= cast()_ptr3370; + auto _list3371 = WitString(_ptr3370[0.._len3370]); + auto _len3372 = *(cast(size_t*)(arg0 + (232+30*size_t.sizeof))); + auto _ptr3372 = _len3372 ? cast(char*)(*(cast(void**)(arg0 + (232+29*size_t.sizeof)))) : null; + if (_len3372) deallocate ~= cast()_ptr3372; + auto _list3373 = WitString(_ptr3372[0.._len3372]); + wit.pumpkin.plugin.uuid.common.Uuid _record3374 = { + high: *(cast(ulong*)(arg0 + (248+32*size_t.sizeof))), + low: *(cast(ulong*)(arg0 + (256+32*size_t.sizeof))), + }; + Option!(wit.pumpkin.plugin.bedrock_packets.common.ServerJoinInformation) _option3410 = void; + bool _isSome3410 = (cast(uint)(*(cast(ubyte*)(arg0 + (272+32*size_t.sizeof))))) != 0; + if (_isSome3410) { + Option!(wit.pumpkin.plugin.bedrock_packets.common.GatheringJoinInfo) _option3392 = void; + bool _isSome3392 = (cast(uint)(*(cast(ubyte*)(arg0 + (280+32*size_t.sizeof))))) != 0; + if (_isSome3392) { + wit.pumpkin.plugin.uuid.common.Uuid _record3379 = { + high: *(cast(ulong*)(arg0 + (288+32*size_t.sizeof))), + low: *(cast(ulong*)(arg0 + (296+32*size_t.sizeof))), + }; + auto _len3380 = *(cast(size_t*)(arg0 + (304+33*size_t.sizeof))); + auto _ptr3380 = _len3380 ? cast(char*)(*(cast(void**)(arg0 + (304+32*size_t.sizeof)))) : null; + if (_len3380) deallocate ~= cast()_ptr3380; + auto _list3381 = WitString(_ptr3380[0.._len3380]); + wit.pumpkin.plugin.uuid.common.Uuid _record3382 = { + high: *(cast(ulong*)(arg0 + (304+34*size_t.sizeof))), + low: *(cast(ulong*)(arg0 + (312+34*size_t.sizeof))), + }; + auto _len3383 = *(cast(size_t*)(arg0 + (320+35*size_t.sizeof))); + auto _ptr3383 = _len3383 ? cast(char*)(*(cast(void**)(arg0 + (320+34*size_t.sizeof)))) : null; + if (_len3383) deallocate ~= cast()_ptr3383; + auto _list3384 = WitString(_ptr3383[0.._len3383]); + auto _len3385 = *(cast(size_t*)(arg0 + (320+37*size_t.sizeof))); + auto _ptr3385 = _len3385 ? cast(char*)(*(cast(void**)(arg0 + (320+36*size_t.sizeof)))) : null; + if (_len3385) deallocate ~= cast()_ptr3385; + auto _list3386 = WitString(_ptr3385[0.._len3385]); + wit.pumpkin.plugin.uuid.common.Uuid _record3387 = { + high: *(cast(ulong*)(arg0 + (320+38*size_t.sizeof))), + low: *(cast(ulong*)(arg0 + (328+38*size_t.sizeof))), + }; + wit.pumpkin.plugin.uuid.common.Uuid _record3388 = { + high: *(cast(ulong*)(arg0 + (336+38*size_t.sizeof))), + low: *(cast(ulong*)(arg0 + (344+38*size_t.sizeof))), + }; + auto _len3389 = *(cast(size_t*)(arg0 + (352+39*size_t.sizeof))); + auto _ptr3389 = _len3389 ? cast(char*)(*(cast(void**)(arg0 + (352+38*size_t.sizeof)))) : null; + if (_len3389) deallocate ~= cast()_ptr3389; + auto _list3390 = WitString(_ptr3389[0.._len3389]); + wit.pumpkin.plugin.bedrock_packets.common.GatheringJoinInfo _record3391 = { + experienceId: _record3379, + experienceName: _list3381, + experienceWorldId: _record3382, + experienceWorldName: _list3384, + creatorId: _list3386, + unknownUuid1: _record3387, + unknownUuid2: _record3388, + serverId: _list3390, + }; + + _option3392 = Option!(wit.pumpkin.plugin.bedrock_packets.common.GatheringJoinInfo).makeSome(_record3391); + } else { + _option3392 = Option!(wit.pumpkin.plugin.bedrock_packets.common.GatheringJoinInfo).makeNone; + } + Option!(wit.pumpkin.plugin.bedrock_packets.common.StoreEntryPointInfo) _option3400 = void; + bool _isSome3400 = (cast(uint)(*(cast(ubyte*)(arg0 + (352+40*size_t.sizeof))))) != 0; + if (_isSome3400) { + auto _len3395 = *(cast(size_t*)(arg0 + (352+42*size_t.sizeof))); + auto _ptr3395 = _len3395 ? cast(char*)(*(cast(void**)(arg0 + (352+41*size_t.sizeof)))) : null; + if (_len3395) deallocate ~= cast()_ptr3395; + auto _list3396 = WitString(_ptr3395[0.._len3395]); + auto _len3397 = *(cast(size_t*)(arg0 + (352+44*size_t.sizeof))); + auto _ptr3397 = _len3397 ? cast(char*)(*(cast(void**)(arg0 + (352+43*size_t.sizeof)))) : null; + if (_len3397) deallocate ~= cast()_ptr3397; + auto _list3398 = WitString(_ptr3397[0.._len3397]); + wit.pumpkin.plugin.bedrock_packets.common.StoreEntryPointInfo _record3399 = { + storeId: _list3396, + storeName: _list3398, + }; + + _option3400 = Option!(wit.pumpkin.plugin.bedrock_packets.common.StoreEntryPointInfo).makeSome(_record3399); + } else { + _option3400 = Option!(wit.pumpkin.plugin.bedrock_packets.common.StoreEntryPointInfo).makeNone; + } + Option!(wit.pumpkin.plugin.bedrock_packets.common.PresenceInfo) _option3408 = void; + bool _isSome3408 = (cast(uint)(*(cast(ubyte*)(arg0 + (352+45*size_t.sizeof))))) != 0; + if (_isSome3408) { + auto _len3403 = *(cast(size_t*)(arg0 + (352+47*size_t.sizeof))); + auto _ptr3403 = _len3403 ? cast(char*)(*(cast(void**)(arg0 + (352+46*size_t.sizeof)))) : null; + if (_len3403) deallocate ~= cast()_ptr3403; + auto _list3404 = WitString(_ptr3403[0.._len3403]); + auto _len3405 = *(cast(size_t*)(arg0 + (352+49*size_t.sizeof))); + auto _ptr3405 = _len3405 ? cast(char*)(*(cast(void**)(arg0 + (352+48*size_t.sizeof)))) : null; + if (_len3405) deallocate ~= cast()_ptr3405; + auto _list3406 = WitString(_ptr3405[0.._len3405]); + wit.pumpkin.plugin.bedrock_packets.common.PresenceInfo _record3407 = { + experienceName: _list3404, + worldName: _list3406, + }; + + _option3408 = Option!(wit.pumpkin.plugin.bedrock_packets.common.PresenceInfo).makeSome(_record3407); + } else { + _option3408 = Option!(wit.pumpkin.plugin.bedrock_packets.common.PresenceInfo).makeNone; + } + wit.pumpkin.plugin.bedrock_packets.common.ServerJoinInformation _record3409 = { + gathering: _option3392, + storeEntryPoint: _option3400, + presence: _option3408, + }; + + _option3410 = Option!(wit.pumpkin.plugin.bedrock_packets.common.ServerJoinInformation).makeSome(_record3409); + } else { + _option3410 = Option!(wit.pumpkin.plugin.bedrock_packets.common.ServerJoinInformation).makeNone; + } + auto _len3411 = *(cast(size_t*)(arg0 + (352+51*size_t.sizeof))); + auto _ptr3411 = _len3411 ? cast(char*)(*(cast(void**)(arg0 + (352+50*size_t.sizeof)))) : null; + if (_len3411) deallocate ~= cast()_ptr3411; + auto _list3412 = WitString(_ptr3411[0.._len3411]); + auto _len3413 = *(cast(size_t*)(arg0 + (352+53*size_t.sizeof))); + auto _ptr3413 = _len3413 ? cast(char*)(*(cast(void**)(arg0 + (352+52*size_t.sizeof)))) : null; + if (_len3413) deallocate ~= cast()_ptr3413; + auto _list3414 = WitString(_ptr3413[0.._len3413]); + auto _len3415 = *(cast(size_t*)(arg0 + (352+55*size_t.sizeof))); + auto _ptr3415 = _len3415 ? cast(char*)(*(cast(void**)(arg0 + (352+54*size_t.sizeof)))) : null; + if (_len3415) deallocate ~= cast()_ptr3415; + auto _list3416 = WitString(_ptr3415[0.._len3415]); + auto _len3417 = *(cast(size_t*)(arg0 + (352+57*size_t.sizeof))); + auto _ptr3417 = _len3417 ? cast(char*)(*(cast(void**)(arg0 + (352+56*size_t.sizeof)))) : null; + if (_len3417) deallocate ~= cast()_ptr3417; + auto _list3418 = WitString(_ptr3417[0.._len3417]); + wit.pumpkin.plugin.bedrock_packets.common.ServerTelemetryData _record3419 = { + serverId: _list3412, + scenarioId: _list3414, + worldId: _list3416, + ownerId: _list3418, + }; + wit.pumpkin.plugin.bedrock_packets.common.CStartGame _record3420 = { + entityId: cast(long)(*(cast(ulong*)(arg0 + 40))), + runtimeEntityId: cast(long)(*(cast(ulong*)(arg0 + 48))), + playerGamemode: cast(wit.pumpkin.plugin.bedrock_packets.common.GameType)(cast(uint)(*(cast(ubyte*)(arg0 + 56)))), + position: _tuple3338, + pitch: *(cast(float*)(arg0 + 88)), + yaw: *(cast(float*)(arg0 + 92)), + levelSettings: _record3363, + levelId: _list3365, + levelName: _list3367, + premiumWorldTemplateId: _list3369, + isTrial: (cast(uint)(*(cast(ubyte*)(arg0 + (200+26*size_t.sizeof))))) != 0, + rewindHistorySize: cast(int)(*(cast(uint*)(arg0 + (204+26*size_t.sizeof)))), + serverAuthoritativeBlockBreaking: (cast(uint)(*(cast(ubyte*)(arg0 + (208+26*size_t.sizeof))))) != 0, + currentLevelTime: cast(long)(*(cast(ulong*)(arg0 + (216+26*size_t.sizeof)))), + enchantmentSeed: cast(int)(*(cast(uint*)(arg0 + (224+26*size_t.sizeof)))), + blockPropertiesSize: cast(int)(*(cast(uint*)(arg0 + (228+26*size_t.sizeof)))), + multiplayerCorrelationId: _list3371, + enableItemstackNetManager: (cast(uint)(*(cast(ubyte*)(arg0 + (232+28*size_t.sizeof))))) != 0, + serverVersion: _list3373, + compoundId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (232+31*size_t.sizeof))))), + compoundLen: cast(int)(*(cast(uint*)(arg0 + (236+31*size_t.sizeof)))), + compoundEnd: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (240+31*size_t.sizeof))))), + blockRegistryChecksum: cast(long)(*(cast(ulong*)(arg0 + (240+32*size_t.sizeof)))), + worldTemplateId: _record3374, + enableClientsideGeneration: (cast(uint)(*(cast(ubyte*)(arg0 + (264+32*size_t.sizeof))))) != 0, + blocknetworkIdsAreHashed: (cast(uint)(*(cast(ubyte*)(arg0 + (265+32*size_t.sizeof))))) != 0, + serverAuthSounds: (cast(uint)(*(cast(ubyte*)(arg0 + (266+32*size_t.sizeof))))) != 0, + serverJoinInformation: _option3410, + telemetry: _record3419, + }; + auto _payload3510 = _record3420; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cStartGame(_payload3510); + break; + } + case _Tag3458.cTakeItemActor: { + wit.pumpkin.plugin.bedrock_packets.common.CTakeItemActor _record3422 = { + itemRuntimeId: cast(long)(*(cast(ulong*)(arg0 + 40))), + actorRuntimeId: cast(long)(*(cast(ulong*)(arg0 + 48))), + }; + auto _payload3511 = _record3422; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cTakeItemActor(_payload3511); + break; + } + case _Tag3458.cTransfer: { + auto _len3424 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr3424 = _len3424 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len3424) deallocate ~= cast()_ptr3424; + auto _list3425 = WitString(_ptr3424[0.._len3424]); + wit.pumpkin.plugin.bedrock_packets.common.CTransfer _record3426 = { + serverAddress: _list3425, + serverPort: cast(int)(*(cast(uint*)(arg0 + (40+2*size_t.sizeof)))), + reloadWorld: (cast(uint)(*(cast(ubyte*)(arg0 + (44+2*size_t.sizeof))))) != 0, + }; + auto _payload3512 = _record3426; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cTransfer(_payload3512); + break; + } + case _Tag3458.cUpdateAbilities: { + auto _len3428 = *(cast(size_t*)(arg0 + (48+2*size_t.sizeof))); + auto _ptr3428 = _len3428 ? cast(wit.pumpkin.plugin.bedrock_packets.common.SerializedAbilitiesDataSerializedLayer*)(*(cast(void**)(arg0 + (48+1*size_t.sizeof)))) : null; + if (_len3428) deallocate ~= cast()_ptr3428; + auto _list3429 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.SerializedAbilitiesDataSerializedLayer)(_ptr3428[0.._len3428]); + wit.pumpkin.plugin.bedrock_packets.common.SerializedAbilitiesData _record3430 = { + targetPlayerRawId: cast(long)(*(cast(ulong*)(arg0 + 40))), + playerPermissions: cast(wit.pumpkin.plugin.bedrock_packets.common.PlayerPermissionLevel)(cast(uint)(*(cast(ubyte*)(arg0 + 48)))), + commandPermissions: cast(wit.pumpkin.plugin.bedrock_packets.common.CommandPermissionLevel)(cast(uint)(*(cast(ubyte*)(arg0 + 49)))), + layers: _list3429, + }; + wit.pumpkin.plugin.bedrock_packets.common.CUpdateAbilities _record3431 = { + data: _record3430, + }; + auto _payload3513 = _record3431; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cUpdateAbilities(_payload3513); + break; + } + case _Tag3458.cUpdateAttributes: { + auto _listSrcPtr3445 = *(cast(void**)(arg0 + 48)); + auto _listLen3445 = *(cast(size_t*)(arg0 + (48+1*size_t.sizeof))); + auto _list3445 = _listLen3445 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.AttributeData)(_listLen3445) : []; + assert(!_listLen3445 || _list3445.ptr); + if (_listLen3445) deallocate ~= cast(void*)_list3445.ptr; + foreach (_elem3433_idx, ref _elem3433; _list3445) { + const auto _base3433 = _listSrcPtr3445 + _elem3433_idx * (24+4*size_t.sizeof); + auto _len3434 = *(cast(size_t*)(_base3433 + (24+1*size_t.sizeof))); + auto _ptr3434 = _len3434 ? cast(char*)(*(cast(void**)(_base3433 + 24))) : null; + if (_len3434) deallocate ~= cast()_ptr3434; + auto _list3435 = WitString(_ptr3434[0.._len3434]); + auto _listSrcPtr3442 = *(cast(void**)(_base3433 + (24+2*size_t.sizeof))); + auto _listLen3442 = *(cast(size_t*)(_base3433 + (24+3*size_t.sizeof))); + auto _list3442 = _listLen3442 ? wit.common.mallocSlice!(wit.pumpkin.plugin.bedrock_packets.common.AttributeModifier)(_listLen3442) : []; + assert(!_listLen3442 || _list3442.ptr); + if (_listLen3442) deallocate ~= cast(void*)_list3442.ptr; + foreach (_elem3436_idx, ref _elem3436; _list3442) { + const auto _base3436 = _listSrcPtr3442 + _elem3436_idx * (16+4*size_t.sizeof); + auto _len3437 = *(cast(size_t*)(_base3436 + size_t.sizeof)); + auto _ptr3437 = _len3437 ? cast(char*)(*(cast(void**)(_base3436 + 0))) : null; + if (_len3437) deallocate ~= cast()_ptr3437; + auto _list3438 = WitString(_ptr3437[0.._len3437]); + auto _len3439 = *(cast(size_t*)(_base3436 + (3*size_t.sizeof))); + auto _ptr3439 = _len3439 ? cast(char*)(*(cast(void**)(_base3436 + (2*size_t.sizeof)))) : null; + if (_len3439) deallocate ~= cast()_ptr3439; + auto _list3440 = WitString(_ptr3439[0.._len3439]); + wit.pumpkin.plugin.bedrock_packets.common.AttributeModifier _record3441 = { + id: _list3438, + name: _list3440, + amount: *(cast(float*)(_base3436 + (4*size_t.sizeof))), + operation: cast(int)(*(cast(uint*)(_base3436 + (4+4*size_t.sizeof)))), + operand: cast(int)(*(cast(uint*)(_base3436 + (8+4*size_t.sizeof)))), + isSerializable: (cast(uint)(*(cast(ubyte*)(_base3436 + (12+4*size_t.sizeof))))) != 0, + }; + _elem3436 = _record3441; + } + if (_listLen3442) deallocate ~= _listSrcPtr3442; + auto _witList3443 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.AttributeModifier)(_list3442); + wit.pumpkin.plugin.bedrock_packets.common.AttributeData _record3444 = { + minValue: *(cast(float*)(_base3433 + 0)), + maxValue: *(cast(float*)(_base3433 + 4)), + currentValue: *(cast(float*)(_base3433 + 8)), + defaultMinValue: *(cast(float*)(_base3433 + 12)), + defaultMaxValue: *(cast(float*)(_base3433 + 16)), + defaultValue: *(cast(float*)(_base3433 + 20)), + name: _list3435, + modifiers: _witList3443, + }; + _elem3433 = _record3444; + } + if (_listLen3445) deallocate ~= _listSrcPtr3445; + auto _witList3446 = WitList!(wit.pumpkin.plugin.bedrock_packets.common.AttributeData)(_list3445); + wit.pumpkin.plugin.bedrock_packets.common.CUpdateAttributes _record3447 = { + targetRuntimeId: cast(long)(*(cast(ulong*)(arg0 + 40))), + attributeList: _witList3446, + tick: cast(long)(*(cast(ulong*)(arg0 + (48+2*size_t.sizeof)))), + }; + auto _payload3514 = _record3447; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cUpdateAttributes(_payload3514); + break; + } + case _Tag3458.cUpdateBlock: { + auto _tuple3449 = Tuple!(int, int, int)( + cast(int)(*(cast(uint*)(arg0 + 40))), + cast(int)(*(cast(uint*)(arg0 + 44))), + cast(int)(*(cast(uint*)(arg0 + 48))), + ); + wit.pumpkin.plugin.bedrock_packets.common.CUpdateBlock _record3450 = { + blockPosition: _tuple3449, + blockRuntimeId: cast(int)(*(cast(uint*)(arg0 + 52))), + flags: cast(int)(*(cast(uint*)(arg0 + 56))), + layer: cast(int)(*(cast(uint*)(arg0 + 60))), + }; + auto _payload3515 = _record3450; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cUpdateBlock(_payload3515); + break; + } + case _Tag3458.cUpdateTrade: { + auto _len3452 = *(cast(size_t*)(arg0 + (72+1*size_t.sizeof))); + auto _ptr3452 = _len3452 ? cast(char*)(*(cast(void**)(arg0 + 72))) : null; + if (_len3452) deallocate ~= cast()_ptr3452; + auto _list3453 = WitString(_ptr3452[0.._len3452]); + auto _len3454 = *(cast(size_t*)(arg0 + (72+4*size_t.sizeof))); + auto _ptr3454 = _len3454 ? cast(char*)(*(cast(void**)(arg0 + (72+3*size_t.sizeof)))) : null; + if (_len3454) deallocate ~= cast()_ptr3454; + auto _list3455 = WitString(_ptr3454[0.._len3454]); + wit.pumpkin.plugin.bedrock_packets.common.CUpdateTrade _record3456 = { + containerId: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 40)))), + rType: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 41)))), + size: cast(int)(*(cast(uint*)(arg0 + 44))), + traderTier: cast(int)(*(cast(uint*)(arg0 + 48))), + entityUniqueId: cast(long)(*(cast(ulong*)(arg0 + 56))), + lastTradingPlayer: cast(long)(*(cast(ulong*)(arg0 + 64))), + displayName: _list3453, + useNewTradeScreen: (cast(uint)(*(cast(ubyte*)(arg0 + (72+2*size_t.sizeof))))) != 0, + usingEconomyTrade: (cast(uint)(*(cast(ubyte*)(arg0 + (73+2*size_t.sizeof))))) != 0, + data: _list3455, + }; + auto _payload3516 = _record3456; + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.cUpdateTrade(_payload3516); + break; + } + case _Tag3458.unknown: { + _variant3458 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.unknown(); + break; + } + } + auto _payload3521 = _variant3458; + _variant3519 = wit.pumpkin.plugin.event.common.ClientboundPacket.bedrock(_payload3521); + break; + } + case _Tag3519.unknown: { + _variant3519 = wit.pumpkin.plugin.event.common.ClientboundPacket.unknown(); + break; + } + } + auto _len3523 = *(cast(size_t*)(arg0 + (352+60*size_t.sizeof))); + auto _ptr3523 = _len3523 ? cast(ubyte*)(*(cast(void**)(arg0 + (352+59*size_t.sizeof)))) : null; + if (_len3523) deallocate ~= cast()_ptr3523; + auto _list3524 = WitList!(ubyte)(_ptr3523[0.._len3523]); + wit.pumpkin.plugin.event.imports.PacketSentEventData _record3525 = { + player: _handle1404, + packet: _variant3519, + packetId: cast(int)(*(cast(uint*)(arg0 + (352+58*size_t.sizeof)))), + rawPayload: _list3524, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (352+61*size_t.sizeof))))) != 0, + }; + auto _payload4564 = _record3525; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.packetSentEvent(_payload4564); + break; + } + case _Tag4520.chunkLoadEvent: { + auto _handle3527 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.ChunkLoadEventData _record3528 = { + targetWorld: _handle3527, + chunkX: cast(int)(*(cast(uint*)(arg0 + 20))), + chunkZ: cast(int)(*(cast(uint*)(arg0 + 24))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 28)))) != 0, + }; + auto _payload4565 = _record3528; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.chunkLoadEvent(_payload4565); + break; + } + case _Tag4520.chunkSaveEvent: { + auto _handle3530 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.ChunkSaveEventData _record3531 = { + targetWorld: _handle3530, + chunkX: cast(int)(*(cast(uint*)(arg0 + 20))), + chunkZ: cast(int)(*(cast(uint*)(arg0 + 24))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 28)))) != 0, + }; + auto _payload4566 = _record3531; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.chunkSaveEvent(_payload4566); + break; + } + case _Tag4520.chunkSendEvent: { + auto _handle3533 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.ChunkSendEventData _record3534 = { + targetWorld: _handle3533, + chunkX: cast(int)(*(cast(uint*)(arg0 + 20))), + chunkZ: cast(int)(*(cast(uint*)(arg0 + 24))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 28)))) != 0, + }; + auto _payload4567 = _record3534; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.chunkSendEvent(_payload4567); + break; + } + case _Tag4520.entityDamageEvent: { + wit.pumpkin.plugin.event.common.EntityDamageEventData _record3536 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + damage: *(cast(float*)(arg0 + 20)), + damageType: cast(wit.pumpkin.plugin.damage_types.common.DamageType)(cast(uint)(*(cast(ubyte*)(arg0 + 24)))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 25)))) != 0, + }; + auto _payload4568 = _record3536; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityDamageEvent(_payload4568); + break; + } + case _Tag4520.entityDeathEvent: { + wit.pumpkin.plugin.event.common.EntityDeathEventData _record3538 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + droppedExp: cast(int)(*(cast(uint*)(arg0 + 20))), + }; + auto _payload4569 = _record3538; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityDeathEvent(_payload4569); + break; + } + case _Tag4520.playerDeathEvent: { + auto _handle3540 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _handle3541 = wit.pumpkin.plugin.event.imports.TextComponent(*(cast(uint*)(arg0 + 20))); + wit.pumpkin.plugin.event.imports.PlayerDeathEventData _record3542 = { + player: _handle3540, + deathMessage: _handle3541, + droppedExp: cast(int)(*(cast(uint*)(arg0 + 24))), + keepInventory: (cast(uint)(*(cast(ubyte*)(arg0 + 28)))) != 0, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 29)))) != 0, + }; + auto _payload4570 = _record3542; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerDeathEvent(_payload4570); + break; + } + case _Tag4520.entitySpawnEvent: { + auto _len3544 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr3544 = _len3544 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len3544) deallocate ~= cast()_ptr3544; + auto _list3545 = WitString(_ptr3544[0.._len3544]); + auto _tuple3546 = wit.pumpkin.plugin.common.common.Position( + *(cast(double*)(arg0 + (24+2*size_t.sizeof))), + *(cast(double*)(arg0 + (32+2*size_t.sizeof))), + *(cast(double*)(arg0 + (40+2*size_t.sizeof))), + ); + auto _handle3547 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + (48+2*size_t.sizeof)))); + wit.pumpkin.plugin.event.imports.EntitySpawnEventData _record3548 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + entityType: _list3545, + position: _tuple3546, + targetWorld: _handle3547, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (52+2*size_t.sizeof))))) != 0, + }; + auto _payload4571 = _record3548; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entitySpawnEvent(_payload4571); + break; + } + case _Tag4520.entityCombustEvent: { + wit.pumpkin.plugin.event.common.EntityCombustEventData _record3550 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + durationSecs: *(cast(float*)(arg0 + 20)), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4572 = _record3550; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityCombustEvent(_payload4572); + break; + } + case _Tag4520.entityRegainHealthEvent: { + wit.pumpkin.plugin.event.common.EntityRegainHealthEventData _record3552 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + amount: *(cast(float*)(arg0 + 20)), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4573 = _record3552; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityRegainHealthEvent(_payload4573); + break; + } + case _Tag4520.entityAirChangeEvent: { + wit.pumpkin.plugin.event.common.EntityAirChangeEventData _record3554 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + amount: cast(int)(*(cast(uint*)(arg0 + 20))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4574 = _record3554; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityAirChangeEvent(_payload4574); + break; + } + case _Tag4520.entityBreedEvent: { + wit.pumpkin.plugin.event.common.EntityBreedEventData _record3556 = { + fatherId: cast(int)(*(cast(uint*)(arg0 + 16))), + motherId: cast(int)(*(cast(uint*)(arg0 + 20))), + childId: cast(int)(*(cast(uint*)(arg0 + 24))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 28)))) != 0, + }; + auto _payload4575 = _record3556; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityBreedEvent(_payload4575); + break; + } + case _Tag4520.entityDismountEvent: { + wit.pumpkin.plugin.event.common.EntityDismountEventData _record3558 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + dismountedId: cast(int)(*(cast(uint*)(arg0 + 20))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4576 = _record3558; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityDismountEvent(_payload4576); + break; + } + case _Tag4520.entityDyeEvent: { + auto _len3560 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr3560 = _len3560 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len3560) deallocate ~= cast()_ptr3560; + auto _list3561 = WitString(_ptr3560[0.._len3560]); + Option!(wit.pumpkin.plugin.event.imports.Player) _option3565 = void; + bool _isSome3565 = (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0; + if (_isSome3565) { + auto _handle3564 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + (20+3*size_t.sizeof)))); + + _option3565 = Option!(wit.pumpkin.plugin.event.imports.Player).makeSome(_handle3564); + } else { + _option3565 = Option!(wit.pumpkin.plugin.event.imports.Player).makeNone; + } + wit.pumpkin.plugin.event.imports.EntityDyeEventData _record3566 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + color: _list3561, + player: _option3565, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (24+3*size_t.sizeof))))) != 0, + }; + auto _payload4577 = _record3566; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityDyeEvent(_payload4577); + break; + } + case _Tag4520.entityEnterLoveModeEvent: { + Option!(int) _option3570 = void; + bool _isSome3570 = (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0; + if (_isSome3570) { + + _option3570 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + 24)))); + } else { + _option3570 = Option!(int).makeNone; + } + wit.pumpkin.plugin.event.common.EntityEnterLoveModeEventData _record3571 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + humanEntityId: _option3570, + ticksInLove: cast(int)(*(cast(uint*)(arg0 + 28))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0, + }; + auto _payload4578 = _record3571; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityEnterLoveModeEvent(_payload4578); + break; + } + case _Tag4520.entityExplodeEvent: { + auto _tuple3573 = wit.pumpkin.plugin.common.common.Position( + *(cast(double*)(arg0 + 24)), + *(cast(double*)(arg0 + 32)), + *(cast(double*)(arg0 + 40)), + ); + wit.pumpkin.plugin.event.common.EntityExplodeEventData _record3574 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + position: _tuple3573, + yieldRate: *(cast(float*)(arg0 + 48)), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 52)))) != 0, + }; + auto _payload4579 = _record3574; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityExplodeEvent(_payload4579); + break; + } + case _Tag4520.entityMountEvent: { + wit.pumpkin.plugin.event.common.EntityMountEventData _record3576 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + mountedId: cast(int)(*(cast(uint*)(arg0 + 20))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4580 = _record3576; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityMountEvent(_payload4580); + break; + } + case _Tag4520.entityPickupItemEvent: { + auto _len3578 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr3578 = _len3578 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len3578) deallocate ~= cast()_ptr3578; + auto _list3579 = WitString(_ptr3578[0.._len3578]); + wit.pumpkin.plugin.event.common.EntityPickupItemEventData _record3580 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + itemName: _list3579, + count: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (17+3*size_t.sizeof))))) != 0, + }; + auto _payload4581 = _record3580; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityPickupItemEvent(_payload4581); + break; + } + case _Tag4520.entityPortalEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3582 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + wit.pumpkin.plugin.event.common.EntityPortalEventData _record3583 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + portalPos: _record3582, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0, + }; + auto _payload4582 = _record3583; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityPortalEvent(_payload4582); + break; + } + case _Tag4520.entityResurrectEvent: { + wit.pumpkin.plugin.event.common.EntityResurrectEventData _record3585 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0, + }; + auto _payload4583 = _record3585; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityResurrectEvent(_payload4583); + break; + } + case _Tag4520.entityShootBowEvent: { + auto _len3587 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr3587 = _len3587 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len3587) deallocate ~= cast()_ptr3587; + auto _list3588 = WitString(_ptr3587[0.._len3587]); + wit.pumpkin.plugin.event.common.EntityShootBowEventData _record3589 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + weaponName: _list3588, + force: *(cast(float*)(arg0 + (16+3*size_t.sizeof))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (20+3*size_t.sizeof))))) != 0, + }; + auto _payload4584 = _record3589; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityShootBowEvent(_payload4584); + break; + } + case _Tag4520.entityTameEvent: { + auto _handle3591 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 20))); + wit.pumpkin.plugin.event.imports.EntityTameEventData _record3592 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + owner: _handle3591, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4585 = _record3592; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityTameEvent(_payload4585); + break; + } + case _Tag4520.entityTargetEvent: { + Option!(int) _option3596 = void; + bool _isSome3596 = (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0; + if (_isSome3596) { + + _option3596 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + 24)))); + } else { + _option3596 = Option!(int).makeNone; + } + wit.pumpkin.plugin.event.common.EntityTargetEventData _record3597 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + targetId: _option3596, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 28)))) != 0, + }; + auto _payload4586 = _record3597; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityTargetEvent(_payload4586); + break; + } + case _Tag4520.entityTeleportEvent: { + auto _tuple3599 = wit.pumpkin.plugin.common.common.Position( + *(cast(double*)(arg0 + 24)), + *(cast(double*)(arg0 + 32)), + *(cast(double*)(arg0 + 40)), + ); + auto _tuple3600 = wit.pumpkin.plugin.common.common.Position( + *(cast(double*)(arg0 + 48)), + *(cast(double*)(arg0 + 56)), + *(cast(double*)(arg0 + 64)), + ); + wit.pumpkin.plugin.event.common.EntityTeleportEventData _record3601 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + fromPosition: _tuple3599, + toPosition: _tuple3600, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 72)))) != 0, + }; + auto _payload4587 = _record3601; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityTeleportEvent(_payload4587); + break; + } + case _Tag4520.entityToggleGlideEvent: { + wit.pumpkin.plugin.event.common.EntityToggleGlideEventData _record3603 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + isGliding: (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 21)))) != 0, + }; + auto _payload4588 = _record3603; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityToggleGlideEvent(_payload4588); + break; + } + case _Tag4520.entityTransformEvent: { + auto _len3605 = *(cast(size_t*)(arg0 + (24+1*size_t.sizeof))); + auto _ptr3605 = _len3605 ? cast(char*)(*(cast(void**)(arg0 + 24))) : null; + if (_len3605) deallocate ~= cast()_ptr3605; + auto _list3606 = WitString(_ptr3605[0.._len3605]); + wit.pumpkin.plugin.event.common.EntityTransformEventData _record3607 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + newEntityId: cast(int)(*(cast(uint*)(arg0 + 20))), + transformReason: _list3606, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (24+2*size_t.sizeof))))) != 0, + }; + auto _payload4589 = _record3607; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityTransformEvent(_payload4589); + break; + } + case _Tag4520.playerItemConsumeEvent: { + auto _handle3609 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len3610 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr3610 = _len3610 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len3610) deallocate ~= cast()_ptr3610; + auto _list3611 = WitString(_ptr3610[0.._len3610]); + wit.pumpkin.plugin.event.imports.PlayerItemConsumeEventData _record3612 = { + player: _handle3609, + itemName: _list3611, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + }; + auto _payload4590 = _record3612; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerItemConsumeEvent(_payload4590); + break; + } + case _Tag4520.playerItemDamageEvent: { + auto _handle3614 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len3615 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr3615 = _len3615 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len3615) deallocate ~= cast()_ptr3615; + auto _list3616 = WitString(_ptr3615[0.._len3615]); + wit.pumpkin.plugin.event.imports.PlayerItemDamageEventData _record3617 = { + player: _handle3614, + itemName: _list3616, + damage: cast(int)(*(cast(uint*)(arg0 + (16+3*size_t.sizeof)))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (20+3*size_t.sizeof))))) != 0, + }; + auto _payload4591 = _record3617; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerItemDamageEvent(_payload4591); + break; + } + case _Tag4520.playerDropItemEvent: { + auto _handle3619 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len3620 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr3620 = _len3620 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len3620) deallocate ~= cast()_ptr3620; + auto _list3621 = WitString(_ptr3620[0.._len3620]); + wit.pumpkin.plugin.event.imports.PlayerDropItemEventData _record3622 = { + player: _handle3619, + itemName: _list3621, + count: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (17+3*size_t.sizeof))))) != 0, + }; + auto _payload4592 = _record3622; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerDropItemEvent(_payload4592); + break; + } + case _Tag4520.playerBedEnterEvent: { + auto _handle3624 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.common.common.BlockPos _record3625 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + wit.pumpkin.plugin.event.imports.PlayerBedEnterEventData _record3626 = { + player: _handle3624, + bedPos: _record3625, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0, + }; + auto _payload4593 = _record3626; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerBedEnterEvent(_payload4593); + break; + } + case _Tag4520.playerBedLeaveEvent: { + auto _handle3628 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.common.common.BlockPos _record3629 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + wit.pumpkin.plugin.event.imports.PlayerBedLeaveEventData _record3630 = { + player: _handle3628, + bedPos: _record3629, + }; + auto _payload4594 = _record3630; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerBedLeaveEvent(_payload4594); + break; + } + case _Tag4520.playerBucketEmptyEvent: { + auto _handle3632 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.common.common.BlockPos _record3633 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + auto _len3634 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + auto _ptr3634 = _len3634 ? cast(char*)(*(cast(void**)(arg0 + 32))) : null; + if (_len3634) deallocate ~= cast()_ptr3634; + auto _list3635 = WitString(_ptr3634[0.._len3634]); + wit.pumpkin.plugin.event.imports.PlayerBucketEmptyEventData _record3636 = { + player: _handle3632, + blockPos: _record3633, + bucket: _list3635, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (32+2*size_t.sizeof))))) != 0, + }; + auto _payload4595 = _record3636; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerBucketEmptyEvent(_payload4595); + break; + } + case _Tag4520.playerBucketFillEvent: { + auto _handle3638 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.common.common.BlockPos _record3639 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + auto _len3640 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + auto _ptr3640 = _len3640 ? cast(char*)(*(cast(void**)(arg0 + 32))) : null; + if (_len3640) deallocate ~= cast()_ptr3640; + auto _list3641 = WitString(_ptr3640[0.._len3640]); + wit.pumpkin.plugin.event.imports.PlayerBucketFillEventData _record3642 = { + player: _handle3638, + blockPos: _record3639, + bucket: _list3641, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (32+2*size_t.sizeof))))) != 0, + }; + auto _payload4596 = _record3642; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerBucketFillEvent(_payload4596); + break; + } + case _Tag4520.blockDamageEvent: { + auto _handle3644 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.common.common.BlockPos _record3645 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + wit.pumpkin.plugin.event.imports.BlockDamageEventData _record3646 = { + player: _handle3644, + blockPos: _record3645, + instaBreak: (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 33)))) != 0, + }; + auto _payload4597 = _record3646; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockDamageEvent(_payload4597); + break; + } + case _Tag4520.blockIgniteEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3648 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + wit.pumpkin.plugin.event.common.BlockIgniteEventData _record3649 = { + blockPos: _record3648, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 28)))) != 0, + }; + auto _payload4598 = _record3649; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockIgniteEvent(_payload4598); + break; + } + case _Tag4520.blockFromToEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3651 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + wit.pumpkin.plugin.common.common.BlockPos _record3652 = { + x: cast(int)(*(cast(uint*)(arg0 + 28))), + y: cast(int)(*(cast(uint*)(arg0 + 32))), + z: cast(int)(*(cast(uint*)(arg0 + 36))), + }; + wit.pumpkin.plugin.event.common.BlockFromToEventData _record3653 = { + fromPos: _record3651, + toPos: _record3652, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0, + }; + auto _payload4599 = _record3653; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockFromToEvent(_payload4599); + break; + } + case _Tag4520.blockFormEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3655 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + wit.pumpkin.plugin.event.common.BlockFormEventData _record3656 = { + blockPos: _record3655, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 28)))) != 0, + }; + auto _payload4600 = _record3656; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockFormEvent(_payload4600); + break; + } + case _Tag4520.blockFadeEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3658 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + wit.pumpkin.plugin.event.common.BlockFadeEventData _record3659 = { + blockPos: _record3658, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 28)))) != 0, + }; + auto _payload4601 = _record3659; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockFadeEvent(_payload4601); + break; + } + case _Tag4520.blockDispenseEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3661 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _len3662 = *(cast(size_t*)(arg0 + (24+2*size_t.sizeof))); + auto _ptr3662 = _len3662 ? cast(char*)(*(cast(void**)(arg0 + (24+1*size_t.sizeof)))) : null; + if (_len3662) deallocate ~= cast()_ptr3662; + auto _list3663 = WitString(_ptr3662[0.._len3662]); + wit.pumpkin.plugin.event.common.BlockDispenseEventData _record3664 = { + blockPos: _record3661, + itemName: _list3663, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (24+3*size_t.sizeof))))) != 0, + }; + auto _payload4602 = _record3664; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockDispenseEvent(_payload4602); + break; + } + case _Tag4520.blockExplodeEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3666 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + wit.pumpkin.plugin.event.common.BlockExplodeEventData _record3667 = { + blockPos: _record3666, + yieldRate: *(cast(float*)(arg0 + 28)), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0, + }; + auto _payload4603 = _record3667; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockExplodeEvent(_payload4603); + break; + } + case _Tag4520.blockPhysicsEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3669 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + wit.pumpkin.plugin.common.common.BlockPos _record3670 = { + x: cast(int)(*(cast(uint*)(arg0 + 28))), + y: cast(int)(*(cast(uint*)(arg0 + 32))), + z: cast(int)(*(cast(uint*)(arg0 + 36))), + }; + wit.pumpkin.plugin.event.common.BlockPhysicsEventData _record3671 = { + blockPos: _record3669, + changedPos: _record3670, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0, + }; + auto _payload4604 = _record3671; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockPhysicsEvent(_payload4604); + break; + } + case _Tag4520.blockPistonExtendEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3673 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _len3674 = *(cast(size_t*)(arg0 + (24+2*size_t.sizeof))); + auto _ptr3674 = _len3674 ? cast(char*)(*(cast(void**)(arg0 + (24+1*size_t.sizeof)))) : null; + if (_len3674) deallocate ~= cast()_ptr3674; + auto _list3675 = WitString(_ptr3674[0.._len3674]); + wit.pumpkin.plugin.event.common.BlockPistonExtendEventData _record3676 = { + blockPos: _record3673, + direction: _list3675, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (24+3*size_t.sizeof))))) != 0, + }; + auto _payload4605 = _record3676; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockPistonExtendEvent(_payload4605); + break; + } + case _Tag4520.blockPistonRetractEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3678 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _len3679 = *(cast(size_t*)(arg0 + (24+2*size_t.sizeof))); + auto _ptr3679 = _len3679 ? cast(char*)(*(cast(void**)(arg0 + (24+1*size_t.sizeof)))) : null; + if (_len3679) deallocate ~= cast()_ptr3679; + auto _list3680 = WitString(_ptr3679[0.._len3679]); + wit.pumpkin.plugin.event.common.BlockPistonRetractEventData _record3681 = { + blockPos: _record3678, + direction: _list3680, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (24+3*size_t.sizeof))))) != 0, + }; + auto _payload4606 = _record3681; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockPistonRetractEvent(_payload4606); + break; + } + case _Tag4520.notePlayEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3683 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _len3684 = *(cast(size_t*)(arg0 + (24+2*size_t.sizeof))); + auto _ptr3684 = _len3684 ? cast(char*)(*(cast(void**)(arg0 + (24+1*size_t.sizeof)))) : null; + if (_len3684) deallocate ~= cast()_ptr3684; + auto _list3685 = WitString(_ptr3684[0.._len3684]); + wit.pumpkin.plugin.event.common.NotePlayEventData _record3686 = { + blockPos: _record3683, + instrument: _list3685, + note: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (24+3*size_t.sizeof))))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (25+3*size_t.sizeof))))) != 0, + }; + auto _payload4607 = _record3686; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.notePlayEvent(_payload4607); + break; + } + case _Tag4520.signChangeEvent: { + auto _handle3688 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.common.common.BlockPos _record3689 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + auto _listSrcPtr3693 = *(cast(void**)(arg0 + 32)); + auto _listLen3693 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + auto _list3693 = _listLen3693 ? wit.common.mallocSlice!(WitString)(_listLen3693) : []; + assert(!_listLen3693 || _list3693.ptr); + if (_listLen3693) deallocate ~= cast(void*)_list3693.ptr; + foreach (_elem3690_idx, ref _elem3690; _list3693) { + const auto _base3690 = _listSrcPtr3693 + _elem3690_idx * (2*size_t.sizeof); + auto _len3691 = *(cast(size_t*)(_base3690 + size_t.sizeof)); + auto _ptr3691 = _len3691 ? cast(char*)(*(cast(void**)(_base3690 + 0))) : null; + if (_len3691) deallocate ~= cast()_ptr3691; + auto _list3692 = WitString(_ptr3691[0.._len3691]); + _elem3690 = _list3692; + } + if (_listLen3693) deallocate ~= _listSrcPtr3693; + auto _witList3694 = WitList!(WitString)(_list3693); + wit.pumpkin.plugin.event.imports.SignChangeEventData _record3695 = { + player: _handle3688, + blockPos: _record3689, + lines: _witList3694, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (32+2*size_t.sizeof))))) != 0, + }; + auto _payload4608 = _record3695; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.signChangeEvent(_payload4608); + break; + } + case _Tag4520.spongeAbsorbEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3697 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + wit.pumpkin.plugin.event.common.SpongeAbsorbEventData _record3698 = { + blockPos: _record3697, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 28)))) != 0, + }; + auto _payload4609 = _record3698; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.spongeAbsorbEvent(_payload4609); + break; + } + case _Tag4520.tntPrimeEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3700 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _len3701 = *(cast(size_t*)(arg0 + (24+2*size_t.sizeof))); + auto _ptr3701 = _len3701 ? cast(char*)(*(cast(void**)(arg0 + (24+1*size_t.sizeof)))) : null; + if (_len3701) deallocate ~= cast()_ptr3701; + auto _list3702 = WitString(_ptr3701[0.._len3701]); + wit.pumpkin.plugin.event.common.TntPrimeEventData _record3703 = { + blockPos: _record3700, + primeReason: _list3702, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (24+3*size_t.sizeof))))) != 0, + }; + auto _payload4610 = _record3703; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.tntPrimeEvent(_payload4610); + break; + } + case _Tag4520.weatherChangeEvent: { + auto _handle3705 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.WeatherChangeEventData _record3706 = { + targetWorld: _handle3705, + toWeatherState: (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 21)))) != 0, + }; + auto _payload4611 = _record3706; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.weatherChangeEvent(_payload4611); + break; + } + case _Tag4520.thunderChangeEvent: { + auto _handle3708 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.ThunderChangeEventData _record3709 = { + targetWorld: _handle3708, + toThunderState: (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 21)))) != 0, + }; + auto _payload4612 = _record3709; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.thunderChangeEvent(_payload4612); + break; + } + case _Tag4520.worldLoadEvent: { + auto _handle3711 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.WorldLoadEventData _record3712 = { + targetWorld: _handle3711, + }; + auto _payload4613 = _record3712; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.worldLoadEvent(_payload4613); + break; + } + case _Tag4520.worldUnloadEvent: { + auto _handle3714 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.WorldUnloadEventData _record3715 = { + targetWorld: _handle3714, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0, + }; + auto _payload4614 = _record3715; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.worldUnloadEvent(_payload4614); + break; + } + case _Tag4520.asyncStructureGenerateEvent: { + auto _len3717 = *(cast(size_t*)(arg0 + (16+1*size_t.sizeof))); + auto _ptr3717 = _len3717 ? cast(char*)(*(cast(void**)(arg0 + 16))) : null; + if (_len3717) deallocate ~= cast()_ptr3717; + auto _list3718 = WitString(_ptr3717[0.._len3717]); + auto _len3719 = *(cast(size_t*)(arg0 + (16+3*size_t.sizeof))); + auto _ptr3719 = _len3719 ? cast(char*)(*(cast(void**)(arg0 + (16+2*size_t.sizeof)))) : null; + if (_len3719) deallocate ~= cast()_ptr3719; + auto _list3720 = WitString(_ptr3719[0.._len3719]); + wit.pumpkin.plugin.common.common.BlockPos _record3721 = { + x: cast(int)(*(cast(uint*)(arg0 + (16+4*size_t.sizeof)))), + y: cast(int)(*(cast(uint*)(arg0 + (20+4*size_t.sizeof)))), + z: cast(int)(*(cast(uint*)(arg0 + (24+4*size_t.sizeof)))), + }; + wit.pumpkin.plugin.event.common.AsyncStructureGenerateEventData _record3722 = { + worldName: _list3718, + structureName: _list3720, + pos: _record3721, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (28+4*size_t.sizeof))))) != 0, + }; + auto _payload4615 = _record3722; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.asyncStructureGenerateEvent(_payload4615); + break; + } + case _Tag4520.asyncStructureSpawnEvent: { + auto _len3724 = *(cast(size_t*)(arg0 + (16+1*size_t.sizeof))); + auto _ptr3724 = _len3724 ? cast(char*)(*(cast(void**)(arg0 + 16))) : null; + if (_len3724) deallocate ~= cast()_ptr3724; + auto _list3725 = WitString(_ptr3724[0.._len3724]); + auto _len3726 = *(cast(size_t*)(arg0 + (16+3*size_t.sizeof))); + auto _ptr3726 = _len3726 ? cast(char*)(*(cast(void**)(arg0 + (16+2*size_t.sizeof)))) : null; + if (_len3726) deallocate ~= cast()_ptr3726; + auto _list3727 = WitString(_ptr3726[0.._len3726]); + wit.pumpkin.plugin.common.common.BlockPos _record3728 = { + x: cast(int)(*(cast(uint*)(arg0 + (16+4*size_t.sizeof)))), + y: cast(int)(*(cast(uint*)(arg0 + (20+4*size_t.sizeof)))), + z: cast(int)(*(cast(uint*)(arg0 + (24+4*size_t.sizeof)))), + }; + wit.pumpkin.plugin.event.common.AsyncStructureSpawnEventData _record3729 = { + worldName: _list3725, + structureName: _list3727, + pos: _record3728, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (28+4*size_t.sizeof))))) != 0, + }; + auto _payload4616 = _record3729; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.asyncStructureSpawnEvent(_payload4616); + break; + } + case _Tag4520.chunkPopulateEvent: { + wit.pumpkin.plugin.event.common.ChunkPopulateEventData _record3731 = { + chunkX: cast(int)(*(cast(uint*)(arg0 + 16))), + chunkZ: cast(int)(*(cast(uint*)(arg0 + 20))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4617 = _record3731; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.chunkPopulateEvent(_payload4617); + break; + } + case _Tag4520.chunkUnloadEvent: { + wit.pumpkin.plugin.event.common.ChunkUnloadEventData _record3733 = { + chunkX: cast(int)(*(cast(uint*)(arg0 + 16))), + chunkZ: cast(int)(*(cast(uint*)(arg0 + 20))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4618 = _record3733; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.chunkUnloadEvent(_payload4618); + break; + } + case _Tag4520.entitiesLoadEvent: { + wit.pumpkin.plugin.event.common.EntitiesLoadEventData _record3735 = { + chunkX: cast(int)(*(cast(uint*)(arg0 + 16))), + chunkZ: cast(int)(*(cast(uint*)(arg0 + 20))), + entityCount: *(cast(uint*)(arg0 + 24)), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 28)))) != 0, + }; + auto _payload4619 = _record3735; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entitiesLoadEvent(_payload4619); + break; + } + case _Tag4520.entitiesUnloadEvent: { + wit.pumpkin.plugin.event.common.EntitiesUnloadEventData _record3737 = { + chunkX: cast(int)(*(cast(uint*)(arg0 + 16))), + chunkZ: cast(int)(*(cast(uint*)(arg0 + 20))), + entityCount: *(cast(uint*)(arg0 + 24)), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 28)))) != 0, + }; + auto _payload4620 = _record3737; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entitiesUnloadEvent(_payload4620); + break; + } + case _Tag4520.genericGameEvent: { + auto _len3739 = *(cast(size_t*)(arg0 + (16+1*size_t.sizeof))); + auto _ptr3739 = _len3739 ? cast(char*)(*(cast(void**)(arg0 + 16))) : null; + if (_len3739) deallocate ~= cast()_ptr3739; + auto _list3740 = WitString(_ptr3739[0.._len3739]); + auto _tuple3741 = wit.pumpkin.plugin.common.common.Position( + *(cast(double*)(arg0 + (16+2*size_t.sizeof))), + *(cast(double*)(arg0 + (24+2*size_t.sizeof))), + *(cast(double*)(arg0 + (32+2*size_t.sizeof))), + ); + wit.pumpkin.plugin.event.common.GenericGameEventData _record3742 = { + eventId: _list3740, + pos: _tuple3741, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (40+2*size_t.sizeof))))) != 0, + }; + auto _payload4621 = _record3742; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.genericGameEvent(_payload4621); + break; + } + case _Tag4520.lootGenerateEvent: { + auto _len3744 = *(cast(size_t*)(arg0 + (16+1*size_t.sizeof))); + auto _ptr3744 = _len3744 ? cast(char*)(*(cast(void**)(arg0 + 16))) : null; + if (_len3744) deallocate ~= cast()_ptr3744; + auto _list3745 = WitString(_ptr3744[0.._len3744]); + wit.pumpkin.plugin.event.common.LootGenerateEventData _record3746 = { + lootTable: _list3745, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+2*size_t.sizeof))))) != 0, + }; + auto _payload4622 = _record3746; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.lootGenerateEvent(_payload4622); + break; + } + case _Tag4520.portalCreateEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3748 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _len3749 = *(cast(size_t*)(arg0 + (24+2*size_t.sizeof))); + auto _ptr3749 = _len3749 ? cast(char*)(*(cast(void**)(arg0 + (24+1*size_t.sizeof)))) : null; + if (_len3749) deallocate ~= cast()_ptr3749; + auto _list3750 = WitString(_ptr3749[0.._len3749]); + wit.pumpkin.plugin.event.common.PortalCreateEventData _record3751 = { + pos: _record3748, + portalType: _list3750, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (24+3*size_t.sizeof))))) != 0, + }; + auto _payload4623 = _record3751; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.portalCreateEvent(_payload4623); + break; + } + case _Tag4520.structureGrowEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3753 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _len3754 = *(cast(size_t*)(arg0 + (24+2*size_t.sizeof))); + auto _ptr3754 = _len3754 ? cast(char*)(*(cast(void**)(arg0 + (24+1*size_t.sizeof)))) : null; + if (_len3754) deallocate ~= cast()_ptr3754; + auto _list3755 = WitString(_ptr3754[0.._len3754]); + wit.pumpkin.plugin.event.common.StructureGrowEventData _record3756 = { + pos: _record3753, + species: _list3755, + boneMeal: (cast(uint)(*(cast(ubyte*)(arg0 + (24+3*size_t.sizeof))))) != 0, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (25+3*size_t.sizeof))))) != 0, + }; + auto _payload4624 = _record3756; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.structureGrowEvent(_payload4624); + break; + } + case _Tag4520.timeSkipEvent: { + wit.pumpkin.plugin.event.common.TimeSkipEventData _record3758 = { + skipAmount: cast(long)(*(cast(ulong*)(arg0 + 16))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4625 = _record3758; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.timeSkipEvent(_payload4625); + break; + } + case _Tag4520.worldInitEvent: { + auto _handle3760 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.WorldInitEventData _record3761 = { + targetWorld: _handle3760, + }; + auto _payload4626 = _record3761; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.worldInitEvent(_payload4626); + break; + } + case _Tag4520.worldSaveEvent: { + auto _len3763 = *(cast(size_t*)(arg0 + (16+1*size_t.sizeof))); + auto _ptr3763 = _len3763 ? cast(char*)(*(cast(void**)(arg0 + 16))) : null; + if (_len3763) deallocate ~= cast()_ptr3763; + auto _list3764 = WitString(_ptr3763[0.._len3763]); + wit.pumpkin.plugin.event.common.WorldSaveEventData _record3765 = { + worldName: _list3764, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+2*size_t.sizeof))))) != 0, + }; + auto _payload4627 = _record3765; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.worldSaveEvent(_payload4627); + break; + } + case _Tag4520.inventoryOpenEvent: { + auto _handle3767 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.InventoryOpenEventData _record3768 = { + player: _handle3767, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0, + }; + auto _payload4628 = _record3768; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.inventoryOpenEvent(_payload4628); + break; + } + case _Tag4520.inventoryDragEvent: { + auto _handle3770 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.InventoryDragEventData _record3771 = { + player: _handle3770, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0, + }; + auto _payload4629 = _record3771; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.inventoryDragEvent(_payload4629); + break; + } + case _Tag4520.craftItemEvent: { + auto _handle3773 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len3774 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr3774 = _len3774 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len3774) deallocate ~= cast()_ptr3774; + auto _list3775 = WitString(_ptr3774[0.._len3774]); + wit.pumpkin.plugin.event.imports.CraftItemEventData _record3776 = { + player: _handle3773, + recipeId: _list3775, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + }; + auto _payload4630 = _record3776; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.craftItemEvent(_payload4630); + break; + } + case _Tag4520.furnaceSmeltEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3778 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _len3779 = *(cast(size_t*)(arg0 + (24+2*size_t.sizeof))); + auto _ptr3779 = _len3779 ? cast(char*)(*(cast(void**)(arg0 + (24+1*size_t.sizeof)))) : null; + if (_len3779) deallocate ~= cast()_ptr3779; + auto _list3780 = WitString(_ptr3779[0.._len3779]); + auto _len3781 = *(cast(size_t*)(arg0 + (24+4*size_t.sizeof))); + auto _ptr3781 = _len3781 ? cast(char*)(*(cast(void**)(arg0 + (24+3*size_t.sizeof)))) : null; + if (_len3781) deallocate ~= cast()_ptr3781; + auto _list3782 = WitString(_ptr3781[0.._len3781]); + wit.pumpkin.plugin.event.common.FurnaceSmeltEventData _record3783 = { + blockPos: _record3778, + sourceItem: _list3780, + resultItem: _list3782, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (24+5*size_t.sizeof))))) != 0, + }; + auto _payload4631 = _record3783; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.furnaceSmeltEvent(_payload4631); + break; + } + case _Tag4520.brewEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3785 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + wit.pumpkin.plugin.event.common.BrewEventData _record3786 = { + blockPos: _record3785, + fuelLevel: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 28)))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 29)))) != 0, + }; + auto _payload4632 = _record3786; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.brewEvent(_payload4632); + break; + } + case _Tag4520.brewingStandFuelEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3788 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + wit.pumpkin.plugin.event.common.BrewingStandFuelEventData _record3789 = { + blockPos: _record3788, + fuelPower: cast(ushort)(cast(uint)(*(cast(ushort*)(arg0 + 28)))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 30)))) != 0, + }; + auto _payload4633 = _record3789; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.brewingStandFuelEvent(_payload4633); + break; + } + case _Tag4520.furnaceBurnEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3791 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _len3792 = *(cast(size_t*)(arg0 + (24+2*size_t.sizeof))); + auto _ptr3792 = _len3792 ? cast(char*)(*(cast(void**)(arg0 + (24+1*size_t.sizeof)))) : null; + if (_len3792) deallocate ~= cast()_ptr3792; + auto _list3793 = WitString(_ptr3792[0.._len3792]); + wit.pumpkin.plugin.event.common.FurnaceBurnEventData _record3794 = { + blockPos: _record3791, + fuelItem: _list3793, + burnTime: *(cast(uint*)(arg0 + (24+3*size_t.sizeof))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (28+3*size_t.sizeof))))) != 0, + }; + auto _payload4634 = _record3794; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.furnaceBurnEvent(_payload4634); + break; + } + case _Tag4520.furnaceExtractEvent: { + auto _handle3796 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.common.common.BlockPos _record3797 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + auto _len3798 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + auto _ptr3798 = _len3798 ? cast(char*)(*(cast(void**)(arg0 + 32))) : null; + if (_len3798) deallocate ~= cast()_ptr3798; + auto _list3799 = WitString(_ptr3798[0.._len3798]); + wit.pumpkin.plugin.event.imports.FurnaceExtractEventData _record3800 = { + player: _handle3796, + blockPos: _record3797, + itemId: _list3799, + itemAmount: *(cast(uint*)(arg0 + (32+2*size_t.sizeof))), + expGained: *(cast(float*)(arg0 + (36+2*size_t.sizeof))), + }; + auto _payload4635 = _record3800; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.furnaceExtractEvent(_payload4635); + break; + } + case _Tag4520.furnaceStartSmeltEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3802 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _len3803 = *(cast(size_t*)(arg0 + (24+2*size_t.sizeof))); + auto _ptr3803 = _len3803 ? cast(char*)(*(cast(void**)(arg0 + (24+1*size_t.sizeof)))) : null; + if (_len3803) deallocate ~= cast()_ptr3803; + auto _list3804 = WitString(_ptr3803[0.._len3803]); + wit.pumpkin.plugin.event.common.FurnaceStartSmeltEventData _record3805 = { + blockPos: _record3802, + sourceItem: _list3804, + cookingTime: *(cast(uint*)(arg0 + (24+3*size_t.sizeof))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (28+3*size_t.sizeof))))) != 0, + }; + auto _payload4636 = _record3805; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.furnaceStartSmeltEvent(_payload4636); + break; + } + case _Tag4520.hopperInventorySearchEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3807 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + wit.pumpkin.plugin.common.common.BlockPos _record3808 = { + x: cast(int)(*(cast(uint*)(arg0 + 28))), + y: cast(int)(*(cast(uint*)(arg0 + 32))), + z: cast(int)(*(cast(uint*)(arg0 + 36))), + }; + wit.pumpkin.plugin.event.common.HopperInventorySearchEventData _record3809 = { + blockPos: _record3807, + searchPos: _record3808, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0, + }; + auto _payload4637 = _record3809; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.hopperInventorySearchEvent(_payload4637); + break; + } + case _Tag4520.inventoryCreativeEvent: { + auto _handle3811 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len3812 = *(cast(size_t*)(arg0 + (24+1*size_t.sizeof))); + auto _ptr3812 = _len3812 ? cast(char*)(*(cast(void**)(arg0 + 24))) : null; + if (_len3812) deallocate ~= cast()_ptr3812; + auto _list3813 = WitString(_ptr3812[0.._len3812]); + wit.pumpkin.plugin.event.imports.InventoryCreativeEventData _record3814 = { + player: _handle3811, + slot: cast(short)(cast(uint)(*(cast(short*)(arg0 + 20)))), + itemId: _list3813, + itemCount: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (24+2*size_t.sizeof))))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (25+2*size_t.sizeof))))) != 0, + }; + auto _payload4638 = _record3814; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.inventoryCreativeEvent(_payload4638); + break; + } + case _Tag4520.inventoryInteractEvent: { + auto _handle3816 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.InventoryInteractEventData _record3817 = { + player: _handle3816, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0, + }; + auto _payload4639 = _record3817; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.inventoryInteractEvent(_payload4639); + break; + } + case _Tag4520.inventoryMoveItemEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3819 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + wit.pumpkin.plugin.common.common.BlockPos _record3820 = { + x: cast(int)(*(cast(uint*)(arg0 + 28))), + y: cast(int)(*(cast(uint*)(arg0 + 32))), + z: cast(int)(*(cast(uint*)(arg0 + 36))), + }; + auto _len3821 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr3821 = _len3821 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len3821) deallocate ~= cast()_ptr3821; + auto _list3822 = WitString(_ptr3821[0.._len3821]); + wit.pumpkin.plugin.event.common.InventoryMoveItemEventData _record3823 = { + sourcePos: _record3819, + targetPos: _record3820, + itemId: _list3822, + itemAmount: *(cast(uint*)(arg0 + (40+2*size_t.sizeof))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (44+2*size_t.sizeof))))) != 0, + }; + auto _payload4640 = _record3823; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.inventoryMoveItemEvent(_payload4640); + break; + } + case _Tag4520.inventoryPickupItemEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3825 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _len3826 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + auto _ptr3826 = _len3826 ? cast(char*)(*(cast(void**)(arg0 + 32))) : null; + if (_len3826) deallocate ~= cast()_ptr3826; + auto _list3827 = WitString(_ptr3826[0.._len3826]); + wit.pumpkin.plugin.event.common.InventoryPickupItemEventData _record3828 = { + blockPos: _record3825, + itemEntityId: cast(int)(*(cast(uint*)(arg0 + 28))), + itemId: _list3827, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (32+2*size_t.sizeof))))) != 0, + }; + auto _payload4641 = _record3828; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.inventoryPickupItemEvent(_payload4641); + break; + } + case _Tag4520.prepareAnvilEvent: { + auto _handle3830 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len3831 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr3831 = _len3831 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len3831) deallocate ~= cast()_ptr3831; + auto _list3832 = WitString(_ptr3831[0.._len3831]); + wit.pumpkin.plugin.event.imports.PrepareAnvilEventData _record3833 = { + player: _handle3830, + renameText: _list3832, + repairCost: *(cast(uint*)(arg0 + (16+3*size_t.sizeof))), + }; + auto _payload4642 = _record3833; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.prepareAnvilEvent(_payload4642); + break; + } + case _Tag4520.prepareGrindstoneEvent: { + auto _handle3835 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + Option!(WitString) _option3840 = void; + bool _isSome3840 = (cast(uint)(*(cast(ubyte*)(arg0 + (16+1*size_t.sizeof))))) != 0; + if (_isSome3840) { + auto _len3838 = *(cast(size_t*)(arg0 + (16+3*size_t.sizeof))); + auto _ptr3838 = _len3838 ? cast(char*)(*(cast(void**)(arg0 + (16+2*size_t.sizeof)))) : null; + if (_len3838) deallocate ~= cast()_ptr3838; + auto _list3839 = WitString(_ptr3838[0.._len3838]); + + _option3840 = Option!(WitString).makeSome(_list3839); + } else { + _option3840 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.event.imports.PrepareGrindstoneEventData _record3841 = { + player: _handle3835, + resultItem: _option3840, + }; + auto _payload4643 = _record3841; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.prepareGrindstoneEvent(_payload4643); + break; + } + case _Tag4520.prepareInventoryResultEvent: { + auto _handle3843 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + Option!(WitString) _option3848 = void; + bool _isSome3848 = (cast(uint)(*(cast(ubyte*)(arg0 + (16+1*size_t.sizeof))))) != 0; + if (_isSome3848) { + auto _len3846 = *(cast(size_t*)(arg0 + (16+3*size_t.sizeof))); + auto _ptr3846 = _len3846 ? cast(char*)(*(cast(void**)(arg0 + (16+2*size_t.sizeof)))) : null; + if (_len3846) deallocate ~= cast()_ptr3846; + auto _list3847 = WitString(_ptr3846[0.._len3846]); + + _option3848 = Option!(WitString).makeSome(_list3847); + } else { + _option3848 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.event.imports.PrepareInventoryResultEventData _record3849 = { + player: _handle3843, + resultItem: _option3848, + }; + auto _payload4644 = _record3849; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.prepareInventoryResultEvent(_payload4644); + break; + } + case _Tag4520.prepareItemCraftEvent: { + auto _handle3851 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len3852 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr3852 = _len3852 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len3852) deallocate ~= cast()_ptr3852; + auto _list3853 = WitString(_ptr3852[0.._len3852]); + wit.pumpkin.plugin.event.imports.PrepareItemCraftEventData _record3854 = { + player: _handle3851, + recipeId: _list3853, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + }; + auto _payload4645 = _record3854; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.prepareItemCraftEvent(_payload4645); + break; + } + case _Tag4520.prepareSmithingEvent: { + auto _handle3856 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + Option!(WitString) _option3861 = void; + bool _isSome3861 = (cast(uint)(*(cast(ubyte*)(arg0 + (16+1*size_t.sizeof))))) != 0; + if (_isSome3861) { + auto _len3859 = *(cast(size_t*)(arg0 + (16+3*size_t.sizeof))); + auto _ptr3859 = _len3859 ? cast(char*)(*(cast(void**)(arg0 + (16+2*size_t.sizeof)))) : null; + if (_len3859) deallocate ~= cast()_ptr3859; + auto _list3860 = WitString(_ptr3859[0.._len3859]); + + _option3861 = Option!(WitString).makeSome(_list3860); + } else { + _option3861 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.event.imports.PrepareSmithingEventData _record3862 = { + player: _handle3856, + resultItem: _option3861, + }; + auto _payload4646 = _record3862; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.prepareSmithingEvent(_payload4646); + break; + } + case _Tag4520.smithItemEvent: { + auto _handle3864 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len3865 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr3865 = _len3865 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len3865) deallocate ~= cast()_ptr3865; + auto _list3866 = WitString(_ptr3865[0.._len3865]); + wit.pumpkin.plugin.event.imports.SmithItemEventData _record3867 = { + player: _handle3864, + recipeId: _list3866, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + }; + auto _payload4647 = _record3867; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.smithItemEvent(_payload4647); + break; + } + case _Tag4520.tradeSelectEvent: { + auto _handle3869 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.TradeSelectEventData _record3870 = { + player: _handle3869, + slotIndex: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 20)))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 21)))) != 0, + }; + auto _payload4648 = _record3870; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.tradeSelectEvent(_payload4648); + break; + } + case _Tag4520.vehicleBlockCollisionEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3872 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + wit.pumpkin.plugin.event.common.VehicleBlockCollisionEventData _record3873 = { + vehicleId: cast(int)(*(cast(uint*)(arg0 + 16))), + blockPos: _record3872, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0, + }; + auto _payload4649 = _record3873; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.vehicleBlockCollisionEvent(_payload4649); + break; + } + case _Tag4520.vehicleCollisionEvent: { + wit.pumpkin.plugin.event.common.VehicleCollisionEventData _record3875 = { + vehicleId: cast(int)(*(cast(uint*)(arg0 + 16))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0, + }; + auto _payload4650 = _record3875; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.vehicleCollisionEvent(_payload4650); + break; + } + case _Tag4520.vehicleCreateEvent: { + wit.pumpkin.plugin.event.common.VehicleCreateEventData _record3877 = { + vehicleId: cast(int)(*(cast(uint*)(arg0 + 16))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0, + }; + auto _payload4651 = _record3877; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.vehicleCreateEvent(_payload4651); + break; + } + case _Tag4520.vehicleDamageEvent: { + Option!(int) _option3881 = void; + bool _isSome3881 = (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0; + if (_isSome3881) { + + _option3881 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + 28)))); + } else { + _option3881 = Option!(int).makeNone; + } + wit.pumpkin.plugin.event.common.VehicleDamageEventData _record3882 = { + vehicleId: cast(int)(*(cast(uint*)(arg0 + 16))), + damage: *(cast(float*)(arg0 + 20)), + attackerId: _option3881, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0, + }; + auto _payload4652 = _record3882; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.vehicleDamageEvent(_payload4652); + break; + } + case _Tag4520.vehicleDestroyEvent: { + Option!(int) _option3886 = void; + bool _isSome3886 = (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0; + if (_isSome3886) { + + _option3886 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + 24)))); + } else { + _option3886 = Option!(int).makeNone; + } + wit.pumpkin.plugin.event.common.VehicleDestroyEventData _record3887 = { + vehicleId: cast(int)(*(cast(uint*)(arg0 + 16))), + attackerId: _option3886, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 28)))) != 0, + }; + auto _payload4653 = _record3887; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.vehicleDestroyEvent(_payload4653); + break; + } + case _Tag4520.vehicleEnterEvent: { + wit.pumpkin.plugin.event.common.VehicleEnterEventData _record3889 = { + vehicleId: cast(int)(*(cast(uint*)(arg0 + 16))), + enteredId: cast(int)(*(cast(uint*)(arg0 + 20))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4654 = _record3889; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.vehicleEnterEvent(_payload4654); + break; + } + case _Tag4520.vehicleEntityCollisionEvent: { + wit.pumpkin.plugin.event.common.VehicleEntityCollisionEventData _record3891 = { + vehicleId: cast(int)(*(cast(uint*)(arg0 + 16))), + collidedEntityId: cast(int)(*(cast(uint*)(arg0 + 20))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4655 = _record3891; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.vehicleEntityCollisionEvent(_payload4655); + break; + } + case _Tag4520.vehicleExitEvent: { + wit.pumpkin.plugin.event.common.VehicleExitEventData _record3893 = { + vehicleId: cast(int)(*(cast(uint*)(arg0 + 16))), + exitedId: cast(int)(*(cast(uint*)(arg0 + 20))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4656 = _record3893; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.vehicleExitEvent(_payload4656); + break; + } + case _Tag4520.vehicleMoveEvent: { + auto _tuple3895 = wit.pumpkin.plugin.common.common.Position( + *(cast(double*)(arg0 + 24)), + *(cast(double*)(arg0 + 32)), + *(cast(double*)(arg0 + 40)), + ); + auto _tuple3896 = wit.pumpkin.plugin.common.common.Position( + *(cast(double*)(arg0 + 48)), + *(cast(double*)(arg0 + 56)), + *(cast(double*)(arg0 + 64)), + ); + wit.pumpkin.plugin.event.common.VehicleMoveEventData _record3897 = { + vehicleId: cast(int)(*(cast(uint*)(arg0 + 16))), + fromPosition: _tuple3895, + toPosition: _tuple3896, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 72)))) != 0, + }; + auto _payload4657 = _record3897; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.vehicleMoveEvent(_payload4657); + break; + } + case _Tag4520.vehicleUpdateEvent: { + wit.pumpkin.plugin.event.common.VehicleUpdateEventData _record3899 = { + vehicleId: cast(int)(*(cast(uint*)(arg0 + 16))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0, + }; + auto _payload4658 = _record3899; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.vehicleUpdateEvent(_payload4658); + break; + } + case _Tag4520.prepareItemEnchantEvent: { + auto _handle3901 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _handle3902 = wit.pumpkin.plugin.event.imports.ItemStack(*(cast(uint*)(arg0 + 20))); + auto _len3903 = *(cast(size_t*)(arg0 + (24+1*size_t.sizeof))); + auto _ptr3903 = _len3903 ? cast(wit.pumpkin.plugin.event.common.EnchantmentOffer*)(*(cast(void**)(arg0 + 24))) : null; + if (_len3903) deallocate ~= cast()_ptr3903; + auto _list3904 = WitList!(wit.pumpkin.plugin.event.common.EnchantmentOffer)(_ptr3903[0.._len3903]); + wit.pumpkin.plugin.event.imports.PrepareItemEnchantEventData _record3905 = { + player: _handle3901, + item: _handle3902, + offers: _list3904, + bookshelfCount: cast(int)(*(cast(uint*)(arg0 + (24+2*size_t.sizeof)))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (28+2*size_t.sizeof))))) != 0, + }; + auto _payload4659 = _record3905; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.prepareItemEnchantEvent(_payload4659); + break; + } + case _Tag4520.enchantItemEvent: { + auto _handle3907 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _handle3908 = wit.pumpkin.plugin.event.imports.ItemStack(*(cast(uint*)(arg0 + 20))); + auto _listSrcPtr3911 = *(cast(void**)(arg0 + 32)); + auto _listLen3911 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + auto _list3911 = _listLen3911 ? wit.common.mallocSlice!(wit.pumpkin.plugin.event.common.EnchantmentValue)(_listLen3911) : []; + assert(!_listLen3911 || _list3911.ptr); + if (_listLen3911) deallocate ~= cast(void*)_list3911.ptr; + foreach (_elem3909_idx, ref _elem3909; _list3911) { + const auto _base3909 = _listSrcPtr3911 + _elem3909_idx * 8; + wit.pumpkin.plugin.event.common.EnchantmentValue _record3910 = { + enchantment: cast(wit.pumpkin.plugin.enchantments.common.Enchantment)(cast(uint)(*(cast(ubyte*)(_base3909 + 0)))), + level: *(cast(uint*)(_base3909 + 4)), + }; + _elem3909 = _record3910; + } + if (_listLen3911) deallocate ~= _listSrcPtr3911; + auto _witList3912 = WitList!(wit.pumpkin.plugin.event.common.EnchantmentValue)(_list3911); + wit.pumpkin.plugin.event.imports.EnchantItemEventData _record3913 = { + player: _handle3907, + item: _handle3908, + option: cast(int)(*(cast(uint*)(arg0 + 24))), + cost: cast(int)(*(cast(uint*)(arg0 + 28))), + enchantmentsToAdd: _witList3912, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (32+2*size_t.sizeof))))) != 0, + }; + auto _payload4660 = _record3913; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.enchantItemEvent(_payload4660); + break; + } + case _Tag4520.mapInitializeEvent: { + wit.pumpkin.plugin.event.common.MapInitializeEventData _record3915 = { + mapId: cast(int)(*(cast(uint*)(arg0 + 16))), + }; + auto _payload4661 = _record3915; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.mapInitializeEvent(_payload4661); + break; + } + case _Tag4520.hangingBreakEvent: { + Option!(int) _option3919 = void; + bool _isSome3919 = (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0; + if (_isSome3919) { + + _option3919 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + 24)))); + } else { + _option3919 = Option!(int).makeNone; + } + wit.pumpkin.plugin.event.common.HangingBreakEventData _record3920 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + removerEntityId: _option3919, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 28)))) != 0, + }; + auto _payload4662 = _record3920; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.hangingBreakEvent(_payload4662); + break; + } + case _Tag4520.hangingBreakByEntityEvent: { + wit.pumpkin.plugin.event.common.HangingBreakByEntityEventData _record3922 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + removerEntityId: cast(int)(*(cast(uint*)(arg0 + 20))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4663 = _record3922; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.hangingBreakByEntityEvent(_payload4663); + break; + } + case _Tag4520.hangingPlaceEvent: { + Option!(wit.pumpkin.plugin.event.imports.Player) _option3927 = void; + bool _isSome3927 = (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0; + if (_isSome3927) { + auto _handle3926 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 24))); + + _option3927 = Option!(wit.pumpkin.plugin.event.imports.Player).makeSome(_handle3926); + } else { + _option3927 = Option!(wit.pumpkin.plugin.event.imports.Player).makeNone; + } + wit.pumpkin.plugin.common.common.BlockPos _record3928 = { + x: cast(int)(*(cast(uint*)(arg0 + 28))), + y: cast(int)(*(cast(uint*)(arg0 + 32))), + z: cast(int)(*(cast(uint*)(arg0 + 36))), + }; + auto _len3929 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr3929 = _len3929 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len3929) deallocate ~= cast()_ptr3929; + auto _list3930 = WitString(_ptr3929[0.._len3929]); + wit.pumpkin.plugin.event.imports.HangingPlaceEventData _record3931 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + player: _option3927, + blockPos: _record3928, + blockFace: _list3930, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (40+2*size_t.sizeof))))) != 0, + }; + auto _payload4664 = _record3931; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.hangingPlaceEvent(_payload4664); + break; + } + case _Tag4520.bellResonateEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3933 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _handle3934 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 28))); + wit.pumpkin.plugin.event.imports.BellResonateEventData _record3935 = { + blockPos: _record3933, + targetWorld: _handle3934, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0, + }; + auto _payload4665 = _record3935; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.bellResonateEvent(_payload4665); + break; + } + case _Tag4520.bellRingEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3937 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _handle3938 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 28))); + Option!(int) _option3941 = void; + bool _isSome3941 = (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0; + if (_isSome3941) { + + _option3941 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + 36)))); + } else { + _option3941 = Option!(int).makeNone; + } + Option!(WitString) _option3946 = void; + bool _isSome3946 = (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0; + if (_isSome3946) { + auto _len3944 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + auto _ptr3944 = _len3944 ? cast(char*)(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))) : null; + if (_len3944) deallocate ~= cast()_ptr3944; + auto _list3945 = WitString(_ptr3944[0.._len3944]); + + _option3946 = Option!(WitString).makeSome(_list3945); + } else { + _option3946 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.event.imports.BellRingEventData _record3947 = { + blockPos: _record3937, + targetWorld: _handle3938, + entityId: _option3941, + direction: _option3946, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (40+3*size_t.sizeof))))) != 0, + }; + auto _payload4666 = _record3947; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.bellRingEvent(_payload4666); + break; + } + case _Tag4520.blockBrushEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3949 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _handle3950 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 28))); + auto _handle3951 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 32))); + auto _handle3952 = wit.pumpkin.plugin.event.imports.ItemStack(*(cast(uint*)(arg0 + 36))); + wit.pumpkin.plugin.event.imports.BlockBrushEventData _record3953 = { + blockPos: _record3949, + targetWorld: _handle3950, + player: _handle3951, + item: _handle3952, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0, + }; + auto _payload4667 = _record3953; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockBrushEvent(_payload4667); + break; + } + case _Tag4520.blockCookEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3955 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _handle3956 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 28))); + auto _handle3957 = wit.pumpkin.plugin.event.imports.ItemStack(*(cast(uint*)(arg0 + 32))); + auto _handle3958 = wit.pumpkin.plugin.event.imports.ItemStack(*(cast(uint*)(arg0 + 36))); + wit.pumpkin.plugin.event.imports.BlockCookEventData _record3959 = { + blockPos: _record3955, + targetWorld: _handle3956, + source: _handle3957, + result: _handle3958, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0, + }; + auto _payload4668 = _record3959; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockCookEvent(_payload4668); + break; + } + case _Tag4520.blockDamageAbortEvent: { + auto _handle3961 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.common.common.BlockPos _record3962 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + auto _handle3963 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 32))); + auto _handle3964 = wit.pumpkin.plugin.event.imports.ItemStack(*(cast(uint*)(arg0 + 36))); + wit.pumpkin.plugin.event.imports.BlockDamageAbortEventData _record3965 = { + player: _handle3961, + blockPos: _record3962, + targetWorld: _handle3963, + itemInHand: _handle3964, + }; + auto _payload4669 = _record3965; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockDamageAbortEvent(_payload4669); + break; + } + case _Tag4520.blockDispenseArmorEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3967 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _handle3968 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 28))); + auto _handle3969 = wit.pumpkin.plugin.event.imports.ItemStack(*(cast(uint*)(arg0 + 36))); + wit.pumpkin.plugin.event.imports.BlockDispenseArmorEventData _record3970 = { + blockPos: _record3967, + targetWorld: _handle3968, + targetEntityId: cast(int)(*(cast(uint*)(arg0 + 32))), + item: _handle3969, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0, + }; + auto _payload4670 = _record3970; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockDispenseArmorEvent(_payload4670); + break; + } + case _Tag4520.blockDispenseLootEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3972 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _handle3973 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 28))); + auto _len3974 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + auto _ptr3974 = _len3974 ? cast(wit.pumpkin.plugin.event.imports.ItemStack*)(*(cast(void**)(arg0 + 32))) : null; + if (_len3974) deallocate ~= cast()_ptr3974; + auto _list3975 = WitList!(wit.pumpkin.plugin.event.imports.ItemStack)(_ptr3974[0.._len3974]); + wit.pumpkin.plugin.event.imports.BlockDispenseLootEventData _record3976 = { + blockPos: _record3972, + targetWorld: _handle3973, + items: _list3975, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (32+2*size_t.sizeof))))) != 0, + }; + auto _payload4671 = _record3976; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockDispenseLootEvent(_payload4671); + break; + } + case _Tag4520.blockDropItemEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3978 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _handle3979 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 28))); + Option!(wit.pumpkin.plugin.event.imports.Player) _option3983 = void; + bool _isSome3983 = (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0; + if (_isSome3983) { + auto _handle3982 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 36))); + + _option3983 = Option!(wit.pumpkin.plugin.event.imports.Player).makeSome(_handle3982); + } else { + _option3983 = Option!(wit.pumpkin.plugin.event.imports.Player).makeNone; + } + auto _len3984 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr3984 = _len3984 ? cast(wit.pumpkin.plugin.event.imports.ItemStack*)(*(cast(void**)(arg0 + 40))) : null; + if (_len3984) deallocate ~= cast()_ptr3984; + auto _list3985 = WitList!(wit.pumpkin.plugin.event.imports.ItemStack)(_ptr3984[0.._len3984]); + wit.pumpkin.plugin.event.imports.BlockDropItemEventData _record3986 = { + blockPos: _record3978, + targetWorld: _handle3979, + player: _option3983, + items: _list3985, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (40+2*size_t.sizeof))))) != 0, + }; + auto _payload4672 = _record3986; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockDropItemEvent(_payload4672); + break; + } + case _Tag4520.blockExpEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3988 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _handle3989 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 28))); + wit.pumpkin.plugin.event.imports.BlockExpEventData _record3990 = { + blockPos: _record3988, + targetWorld: _handle3989, + exp: cast(int)(*(cast(uint*)(arg0 + 32))), + }; + auto _payload4673 = _record3990; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockExpEvent(_payload4673); + break; + } + case _Tag4520.blockFertilizeEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record3992 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _handle3993 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 28))); + Option!(wit.pumpkin.plugin.event.imports.Player) _option3997 = void; + bool _isSome3997 = (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0; + if (_isSome3997) { + auto _handle3996 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 36))); + + _option3997 = Option!(wit.pumpkin.plugin.event.imports.Player).makeSome(_handle3996); + } else { + _option3997 = Option!(wit.pumpkin.plugin.event.imports.Player).makeNone; + } + auto _len3998 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr3998 = _len3998 ? cast(Tuple!(wit.pumpkin.plugin.event.common.BlockPos, ushort)*)(*(cast(void**)(arg0 + 40))) : null; + if (_len3998) deallocate ~= cast()_ptr3998; + auto _list3999 = WitList!(Tuple!(wit.pumpkin.plugin.event.common.BlockPos, ushort))(_ptr3998[0.._len3998]); + wit.pumpkin.plugin.event.imports.BlockFertilizeEventData _record4000 = { + blockPos: _record3992, + targetWorld: _handle3993, + player: _option3997, + changedBlocks: _list3999, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (40+2*size_t.sizeof))))) != 0, + }; + auto _payload4674 = _record4000; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockFertilizeEvent(_payload4674); + break; + } + case _Tag4520.blockMultiPlaceEvent: { + auto _handle4002 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _handle4003 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 20))); + auto _len4004 = *(cast(size_t*)(arg0 + (24+1*size_t.sizeof))); + auto _ptr4004 = _len4004 ? cast(Tuple!(wit.pumpkin.plugin.event.common.BlockPos, ushort)*)(*(cast(void**)(arg0 + 24))) : null; + if (_len4004) deallocate ~= cast()_ptr4004; + auto _list4005 = WitList!(Tuple!(wit.pumpkin.plugin.event.common.BlockPos, ushort))(_ptr4004[0.._len4004]); + wit.pumpkin.plugin.event.imports.BlockMultiPlaceEventData _record4006 = { + player: _handle4002, + targetWorld: _handle4003, + placedBlocks: _list4005, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (24+2*size_t.sizeof))))) != 0, + }; + auto _payload4675 = _record4006; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockMultiPlaceEvent(_payload4675); + break; + } + case _Tag4520.blockReceiveGameEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4008 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _handle4009 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 28))); + auto _len4010 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + auto _ptr4010 = _len4010 ? cast(char*)(*(cast(void**)(arg0 + 32))) : null; + if (_len4010) deallocate ~= cast()_ptr4010; + auto _list4011 = WitString(_ptr4010[0.._len4010]); + Option!(int) _option4014 = void; + bool _isSome4014 = (cast(uint)(*(cast(ubyte*)(arg0 + (32+2*size_t.sizeof))))) != 0; + if (_isSome4014) { + + _option4014 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + (36+2*size_t.sizeof))))); + } else { + _option4014 = Option!(int).makeNone; + } + wit.pumpkin.plugin.event.imports.BlockReceiveGameEventData _record4015 = { + blockPos: _record4008, + targetWorld: _handle4009, + gameEvent: _list4011, + sourceEntityId: _option4014, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (40+2*size_t.sizeof))))) != 0, + }; + auto _payload4676 = _record4015; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockReceiveGameEvent(_payload4676); + break; + } + case _Tag4520.blockShearEntityEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4017 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _handle4018 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 28))); + auto _handle4019 = wit.pumpkin.plugin.event.imports.ItemStack(*(cast(uint*)(arg0 + 36))); + wit.pumpkin.plugin.event.imports.BlockShearEntityEventData _record4020 = { + blockPos: _record4017, + targetWorld: _handle4018, + targetEntityId: cast(int)(*(cast(uint*)(arg0 + 32))), + item: _handle4019, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0, + }; + auto _payload4677 = _record4020; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockShearEntityEvent(_payload4677); + break; + } + case _Tag4520.blockSpreadEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4022 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + wit.pumpkin.plugin.common.common.BlockPos _record4023 = { + x: cast(int)(*(cast(uint*)(arg0 + 28))), + y: cast(int)(*(cast(uint*)(arg0 + 32))), + z: cast(int)(*(cast(uint*)(arg0 + 36))), + }; + auto _handle4024 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 40))); + wit.pumpkin.plugin.event.imports.BlockSpreadEventData _record4025 = { + sourcePos: _record4022, + targetPos: _record4023, + targetWorld: _handle4024, + newStateId: cast(ushort)(cast(uint)(*(cast(ushort*)(arg0 + 44)))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 46)))) != 0, + }; + auto _payload4678 = _record4025; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.blockSpreadEvent(_payload4678); + break; + } + case _Tag4520.brewingStartEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4027 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _handle4028 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 28))); + wit.pumpkin.plugin.event.imports.BrewingStartEventData _record4029 = { + blockPos: _record4027, + targetWorld: _handle4028, + brewingTime: cast(int)(*(cast(uint*)(arg0 + 32))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 36)))) != 0, + }; + auto _payload4679 = _record4029; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.brewingStartEvent(_payload4679); + break; + } + case _Tag4520.campfireStartEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4031 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _handle4032 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 28))); + auto _handle4033 = wit.pumpkin.plugin.event.imports.ItemStack(*(cast(uint*)(arg0 + 32))); + wit.pumpkin.plugin.event.imports.CampfireStartEventData _record4034 = { + blockPos: _record4031, + targetWorld: _handle4032, + item: _handle4033, + slot: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 36)))), + cookingTime: cast(int)(*(cast(uint*)(arg0 + 40))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 44)))) != 0, + }; + auto _payload4680 = _record4034; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.campfireStartEvent(_payload4680); + break; + } + case _Tag4520.cauldronLevelChangeEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4036 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _handle4037 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 28))); + auto _len4038 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr4038 = _len4038 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len4038) deallocate ~= cast()_ptr4038; + auto _list4039 = WitString(_ptr4038[0.._len4038]); + Option!(int) _option4042 = void; + bool _isSome4042 = (cast(uint)(*(cast(ubyte*)(arg0 + (40+2*size_t.sizeof))))) != 0; + if (_isSome4042) { + + _option4042 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + (44+2*size_t.sizeof))))); + } else { + _option4042 = Option!(int).makeNone; + } + wit.pumpkin.plugin.event.imports.CauldronLevelChangeEventData _record4043 = { + blockPos: _record4036, + targetWorld: _handle4037, + oldLevel: cast(int)(*(cast(uint*)(arg0 + 32))), + newLevel: cast(int)(*(cast(uint*)(arg0 + 36))), + reason: _list4039, + entityId: _option4042, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (48+2*size_t.sizeof))))) != 0, + }; + auto _payload4681 = _record4043; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.cauldronLevelChangeEvent(_payload4681); + break; + } + case _Tag4520.crafterCraftEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4045 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _handle4046 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 28))); + auto _handle4047 = wit.pumpkin.plugin.event.imports.ItemStack(*(cast(uint*)(arg0 + 32))); + wit.pumpkin.plugin.event.imports.CrafterCraftEventData _record4048 = { + blockPos: _record4045, + targetWorld: _handle4046, + result: _handle4047, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 36)))) != 0, + }; + auto _payload4682 = _record4048; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.crafterCraftEvent(_payload4682); + break; + } + case _Tag4520.entityBlockFormEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4050 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + auto _handle4051 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 32))); + wit.pumpkin.plugin.event.imports.EntityBlockFormEventData _record4052 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + blockPos: _record4050, + targetWorld: _handle4051, + newStateId: cast(ushort)(cast(uint)(*(cast(ushort*)(arg0 + 36)))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 38)))) != 0, + }; + auto _payload4683 = _record4052; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityBlockFormEvent(_payload4683); + break; + } + case _Tag4520.fluidLevelChangeEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4054 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _handle4055 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 28))); + wit.pumpkin.plugin.event.imports.FluidLevelChangeEventData _record4056 = { + blockPos: _record4054, + targetWorld: _handle4055, + newStateId: cast(ushort)(cast(uint)(*(cast(ushort*)(arg0 + 32)))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 34)))) != 0, + }; + auto _payload4684 = _record4056; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.fluidLevelChangeEvent(_payload4684); + break; + } + case _Tag4520.inventoryBlockStartEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4058 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _handle4059 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 28))); + wit.pumpkin.plugin.event.imports.InventoryBlockStartEventData _record4060 = { + blockPos: _record4058, + targetWorld: _handle4059, + }; + auto _payload4685 = _record4060; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.inventoryBlockStartEvent(_payload4685); + break; + } + case _Tag4520.leavesDecayEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4062 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _handle4063 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 28))); + wit.pumpkin.plugin.event.imports.LeavesDecayEventData _record4064 = { + blockPos: _record4062, + targetWorld: _handle4063, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0, + }; + auto _payload4686 = _record4064; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.leavesDecayEvent(_payload4686); + break; + } + case _Tag4520.moistureChangeEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4066 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _handle4067 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 28))); + wit.pumpkin.plugin.event.imports.MoistureChangeEventData _record4068 = { + blockPos: _record4066, + targetWorld: _handle4067, + newMoisture: cast(int)(*(cast(uint*)(arg0 + 32))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 36)))) != 0, + }; + auto _payload4687 = _record4068; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.moistureChangeEvent(_payload4687); + break; + } + case _Tag4520.sculkBloomEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4070 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _handle4071 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 28))); + wit.pumpkin.plugin.event.imports.SculkBloomEventData _record4072 = { + blockPos: _record4070, + targetWorld: _handle4071, + charge: cast(int)(*(cast(uint*)(arg0 + 32))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 36)))) != 0, + }; + auto _payload4688 = _record4072; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.sculkBloomEvent(_payload4688); + break; + } + case _Tag4520.vaultDisplayItemEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4074 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _handle4075 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 28))); + auto _handle4076 = wit.pumpkin.plugin.event.imports.ItemStack(*(cast(uint*)(arg0 + 32))); + wit.pumpkin.plugin.event.imports.VaultDisplayItemEventData _record4077 = { + blockPos: _record4074, + targetWorld: _handle4075, + item: _handle4076, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 36)))) != 0, + }; + auto _payload4689 = _record4077; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.vaultDisplayItemEvent(_payload4689); + break; + } + case _Tag4520.creatureSpawnEvent: { + auto _len4079 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4079 = _len4079 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4079) deallocate ~= cast()_ptr4079; + auto _list4080 = WitString(_ptr4079[0.._len4079]); + auto _tuple4081 = wit.pumpkin.plugin.common.common.Position( + *(cast(double*)(arg0 + (24+2*size_t.sizeof))), + *(cast(double*)(arg0 + (32+2*size_t.sizeof))), + *(cast(double*)(arg0 + (40+2*size_t.sizeof))), + ); + auto _handle4082 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + (48+2*size_t.sizeof)))); + auto _len4083 = *(cast(size_t*)(arg0 + (48+4*size_t.sizeof))); + auto _ptr4083 = _len4083 ? cast(char*)(*(cast(void**)(arg0 + (48+3*size_t.sizeof)))) : null; + if (_len4083) deallocate ~= cast()_ptr4083; + auto _list4084 = WitString(_ptr4083[0.._len4083]); + wit.pumpkin.plugin.event.imports.CreatureSpawnEventData _record4085 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + entityType: _list4080, + position: _tuple4081, + targetWorld: _handle4082, + spawnReason: _list4084, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (48+5*size_t.sizeof))))) != 0, + }; + auto _payload4690 = _record4085; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.creatureSpawnEvent(_payload4690); + break; + } + case _Tag4520.enderDragonChangePhaseEvent: { + auto _len4087 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4087 = _len4087 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4087) deallocate ~= cast()_ptr4087; + auto _list4088 = WitString(_ptr4087[0.._len4087]); + auto _len4089 = *(cast(size_t*)(arg0 + (16+4*size_t.sizeof))); + auto _ptr4089 = _len4089 ? cast(char*)(*(cast(void**)(arg0 + (16+3*size_t.sizeof)))) : null; + if (_len4089) deallocate ~= cast()_ptr4089; + auto _list4090 = WitString(_ptr4089[0.._len4089]); + wit.pumpkin.plugin.event.common.EnderDragonChangePhaseEventData _record4091 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + currentPhase: _list4088, + newPhase: _list4090, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+5*size_t.sizeof))))) != 0, + }; + auto _payload4691 = _record4091; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.enderDragonChangePhaseEvent(_payload4691); + break; + } + case _Tag4520.entityBreakDoorEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4093 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + wit.pumpkin.plugin.event.common.EntityBreakDoorEventData _record4094 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + blockPos: _record4093, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0, + }; + auto _payload4692 = _record4094; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityBreakDoorEvent(_payload4692); + break; + } + case _Tag4520.entityChangeBlockEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4096 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + auto _len4097 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + auto _ptr4097 = _len4097 ? cast(char*)(*(cast(void**)(arg0 + 32))) : null; + if (_len4097) deallocate ~= cast()_ptr4097; + auto _list4098 = WitString(_ptr4097[0.._len4097]); + wit.pumpkin.plugin.event.common.EntityChangeBlockEventData _record4099 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + blockPos: _record4096, + newBlock: _list4098, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (32+2*size_t.sizeof))))) != 0, + }; + auto _payload4693 = _record4099; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityChangeBlockEvent(_payload4693); + break; + } + case _Tag4520.entityDamageByBlockEvent: { + Option!(wit.pumpkin.plugin.event.common.BlockPos) _option4104 = void; + bool _isSome4104 = (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0; + if (_isSome4104) { + wit.pumpkin.plugin.common.common.BlockPos _record4103 = { + x: cast(int)(*(cast(uint*)(arg0 + 24))), + y: cast(int)(*(cast(uint*)(arg0 + 28))), + z: cast(int)(*(cast(uint*)(arg0 + 32))), + }; + + _option4104 = Option!(wit.pumpkin.plugin.event.common.BlockPos).makeSome(_record4103); + } else { + _option4104 = Option!(wit.pumpkin.plugin.event.common.BlockPos).makeNone; + } + auto _len4105 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + auto _ptr4105 = _len4105 ? cast(char*)(*(cast(void**)(arg0 + 40))) : null; + if (_len4105) deallocate ~= cast()_ptr4105; + auto _list4106 = WitString(_ptr4105[0.._len4105]); + wit.pumpkin.plugin.event.common.EntityDamageByBlockEventData _record4107 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + damagerPos: _option4104, + damage: *(cast(float*)(arg0 + 36)), + cause: _list4106, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (40+2*size_t.sizeof))))) != 0, + }; + auto _payload4694 = _record4107; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityDamageByBlockEvent(_payload4694); + break; + } + case _Tag4520.entityDamageByEntityEvent: { + auto _len4109 = *(cast(size_t*)(arg0 + (24+2*size_t.sizeof))); + auto _ptr4109 = _len4109 ? cast(char*)(*(cast(void**)(arg0 + (24+1*size_t.sizeof)))) : null; + if (_len4109) deallocate ~= cast()_ptr4109; + auto _list4110 = WitString(_ptr4109[0.._len4109]); + wit.pumpkin.plugin.event.common.EntityDamageByEntityEventData _record4111 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + damagerId: cast(int)(*(cast(uint*)(arg0 + 20))), + damage: *(cast(float*)(arg0 + 24)), + cause: _list4110, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (24+3*size_t.sizeof))))) != 0, + }; + auto _payload4695 = _record4111; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityDamageByEntityEvent(_payload4695); + break; + } + case _Tag4520.entityDropItemEvent: { + auto _len4113 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4113 = _len4113 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4113) deallocate ~= cast()_ptr4113; + auto _list4114 = WitString(_ptr4113[0.._len4113]); + wit.pumpkin.plugin.event.common.EntityDropItemEventData _record4115 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + itemName: _list4114, + count: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (17+3*size_t.sizeof))))) != 0, + }; + auto _payload4696 = _record4115; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityDropItemEvent(_payload4696); + break; + } + case _Tag4520.entityEnterBlockEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4117 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + wit.pumpkin.plugin.event.common.EntityEnterBlockEventData _record4118 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + blockPos: _record4117, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0, + }; + auto _payload4697 = _record4118; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityEnterBlockEvent(_payload4697); + break; + } + case _Tag4520.entityExhaustionEvent: { + wit.pumpkin.plugin.event.common.EntityExhaustionEventData _record4120 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + exhaustion: *(cast(float*)(arg0 + 20)), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4698 = _record4120; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityExhaustionEvent(_payload4698); + break; + } + case _Tag4520.entityInteractEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4122 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + wit.pumpkin.plugin.event.common.EntityInteractEventData _record4123 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + blockPos: _record4122, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0, + }; + auto _payload4699 = _record4123; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityInteractEvent(_payload4699); + break; + } + case _Tag4520.entityKnockbackEvent: { + Option!(int) _option4127 = void; + bool _isSome4127 = (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0; + if (_isSome4127) { + + _option4127 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + 24)))); + } else { + _option4127 = Option!(int).makeNone; + } + auto _tuple4128 = wit.pumpkin.plugin.common.common.Position( + *(cast(double*)(arg0 + 32)), + *(cast(double*)(arg0 + 40)), + *(cast(double*)(arg0 + 48)), + ); + wit.pumpkin.plugin.event.common.EntityKnockbackEventData _record4129 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + hitById: _option4127, + knockback: _tuple4128, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 56)))) != 0, + }; + auto _payload4700 = _record4129; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityKnockbackEvent(_payload4700); + break; + } + case _Tag4520.entityPlaceEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4131 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + auto _len4132 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + auto _ptr4132 = _len4132 ? cast(char*)(*(cast(void**)(arg0 + 32))) : null; + if (_len4132) deallocate ~= cast()_ptr4132; + auto _list4133 = WitString(_ptr4132[0.._len4132]); + wit.pumpkin.plugin.event.common.EntityPlaceEventData _record4134 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + blockPos: _record4131, + blockName: _list4133, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (32+2*size_t.sizeof))))) != 0, + }; + auto _payload4701 = _record4134; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityPlaceEvent(_payload4701); + break; + } + case _Tag4520.entityPoseChangeEvent: { + auto _len4136 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4136 = _len4136 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4136) deallocate ~= cast()_ptr4136; + auto _list4137 = WitString(_ptr4136[0.._len4136]); + wit.pumpkin.plugin.event.common.EntityPoseChangeEventData _record4138 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + pose: _list4137, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + }; + auto _payload4702 = _record4138; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityPoseChangeEvent(_payload4702); + break; + } + case _Tag4520.entityPotionEffectEvent: { + auto _len4140 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4140 = _len4140 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4140) deallocate ~= cast()_ptr4140; + auto _list4141 = WitString(_ptr4140[0.._len4140]); + wit.pumpkin.plugin.event.common.EntityPotionEffectEventData _record4142 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + effectName: _list4141, + duration: cast(int)(*(cast(uint*)(arg0 + (16+3*size_t.sizeof)))), + amplifier: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + (20+3*size_t.sizeof))))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (21+3*size_t.sizeof))))) != 0, + }; + auto _payload4703 = _record4142; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityPotionEffectEvent(_payload4703); + break; + } + case _Tag4520.entitySpellCastEvent: { + auto _len4144 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4144 = _len4144 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4144) deallocate ~= cast()_ptr4144; + auto _list4145 = WitString(_ptr4144[0.._len4144]); + wit.pumpkin.plugin.event.common.EntitySpellCastEventData _record4146 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + spell: _list4145, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + }; + auto _payload4704 = _record4146; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entitySpellCastEvent(_payload4704); + break; + } + case _Tag4520.entityTargetLivingEntityEvent: { + Option!(int) _option4150 = void; + bool _isSome4150 = (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0; + if (_isSome4150) { + + _option4150 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + 24)))); + } else { + _option4150 = Option!(int).makeNone; + } + auto _len4151 = *(cast(size_t*)(arg0 + (24+2*size_t.sizeof))); + auto _ptr4151 = _len4151 ? cast(char*)(*(cast(void**)(arg0 + (24+1*size_t.sizeof)))) : null; + if (_len4151) deallocate ~= cast()_ptr4151; + auto _list4152 = WitString(_ptr4151[0.._len4151]); + wit.pumpkin.plugin.event.common.EntityTargetLivingEntityEventData _record4153 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + targetId: _option4150, + reason: _list4152, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (24+3*size_t.sizeof))))) != 0, + }; + auto _payload4705 = _record4153; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityTargetLivingEntityEvent(_payload4705); + break; + } + case _Tag4520.entityToggleSwimEvent: { + wit.pumpkin.plugin.event.common.EntityToggleSwimEventData _record4155 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + isSwimming: (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 21)))) != 0, + }; + auto _payload4706 = _record4155; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityToggleSwimEvent(_payload4706); + break; + } + case _Tag4520.explosionPrimeEvent: { + wit.pumpkin.plugin.event.common.ExplosionPrimeEventData _record4157 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + radius: *(cast(float*)(arg0 + 20)), + fire: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 25)))) != 0, + }; + auto _payload4707 = _record4157; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.explosionPrimeEvent(_payload4707); + break; + } + case _Tag4520.fireworkExplodeEvent: { + wit.pumpkin.plugin.event.common.FireworkExplodeEventData _record4159 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0, + }; + auto _payload4708 = _record4159; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.fireworkExplodeEvent(_payload4708); + break; + } + case _Tag4520.foodLevelChangeEvent: { + wit.pumpkin.plugin.event.common.FoodLevelChangeEventData _record4161 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + foodLevel: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 20)))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 21)))) != 0, + }; + auto _payload4709 = _record4161; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.foodLevelChangeEvent(_payload4709); + break; + } + case _Tag4520.itemDespawnEvent: { + wit.pumpkin.plugin.event.common.ItemDespawnEventData _record4163 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0, + }; + auto _payload4710 = _record4163; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.itemDespawnEvent(_payload4710); + break; + } + case _Tag4520.itemMergeEvent: { + wit.pumpkin.plugin.event.common.ItemMergeEventData _record4165 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + targetId: cast(int)(*(cast(uint*)(arg0 + 20))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4711 = _record4165; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.itemMergeEvent(_payload4711); + break; + } + case _Tag4520.itemSpawnEvent: { + auto _tuple4167 = wit.pumpkin.plugin.common.common.Position( + *(cast(double*)(arg0 + 24)), + *(cast(double*)(arg0 + 32)), + *(cast(double*)(arg0 + 40)), + ); + auto _len4168 = *(cast(size_t*)(arg0 + (48+1*size_t.sizeof))); + auto _ptr4168 = _len4168 ? cast(char*)(*(cast(void**)(arg0 + 48))) : null; + if (_len4168) deallocate ~= cast()_ptr4168; + auto _list4169 = WitString(_ptr4168[0.._len4168]); + wit.pumpkin.plugin.event.common.ItemSpawnEventData _record4170 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + position: _tuple4167, + itemName: _list4169, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (48+2*size_t.sizeof))))) != 0, + }; + auto _payload4712 = _record4170; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.itemSpawnEvent(_payload4712); + break; + } + case _Tag4520.piglinBarterEvent: { + auto _handle4172 = wit.pumpkin.plugin.event.imports.ItemStack(*(cast(uint*)(arg0 + 20))); + auto _len4173 = *(cast(size_t*)(arg0 + (24+1*size_t.sizeof))); + auto _ptr4173 = _len4173 ? cast(wit.pumpkin.plugin.event.imports.ItemStack*)(*(cast(void**)(arg0 + 24))) : null; + if (_len4173) deallocate ~= cast()_ptr4173; + auto _list4174 = WitList!(wit.pumpkin.plugin.event.imports.ItemStack)(_ptr4173[0.._len4173]); + wit.pumpkin.plugin.event.imports.PiglinBarterEventData _record4175 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + inputItem: _handle4172, + outcome: _list4174, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (24+2*size_t.sizeof))))) != 0, + }; + auto _payload4713 = _record4175; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.piglinBarterEvent(_payload4713); + break; + } + case _Tag4520.projectileHitEvent: { + auto _tuple4177 = wit.pumpkin.plugin.common.common.Position( + *(cast(double*)(arg0 + 24)), + *(cast(double*)(arg0 + 32)), + *(cast(double*)(arg0 + 40)), + ); + Option!(int) _option4180 = void; + bool _isSome4180 = (cast(uint)(*(cast(ubyte*)(arg0 + 48)))) != 0; + if (_isSome4180) { + + _option4180 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + 52)))); + } else { + _option4180 = Option!(int).makeNone; + } + wit.pumpkin.plugin.event.common.ProjectileHitEventData _record4181 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + hitPosition: _tuple4177, + hitEntityId: _option4180, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 56)))) != 0, + }; + auto _payload4714 = _record4181; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.projectileHitEvent(_payload4714); + break; + } + case _Tag4520.projectileLaunchEvent: { + Option!(int) _option4185 = void; + bool _isSome4185 = (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0; + if (_isSome4185) { + + _option4185 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + 24)))); + } else { + _option4185 = Option!(int).makeNone; + } + wit.pumpkin.plugin.event.common.ProjectileLaunchEventData _record4186 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + shooterId: _option4185, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 28)))) != 0, + }; + auto _payload4715 = _record4186; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.projectileLaunchEvent(_payload4715); + break; + } + case _Tag4520.sheepDyeWoolEvent: { + Option!(int) _option4190 = void; + bool _isSome4190 = (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0; + if (_isSome4190) { + + _option4190 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + 28)))); + } else { + _option4190 = Option!(int).makeNone; + } + wit.pumpkin.plugin.event.common.SheepDyeWoolEventData _record4191 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + dyeColor: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 20)))), + playerId: _option4190, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0, + }; + auto _payload4716 = _record4191; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.sheepDyeWoolEvent(_payload4716); + break; + } + case _Tag4520.sheepRegrowWoolEvent: { + wit.pumpkin.plugin.event.common.SheepRegrowWoolEventData _record4193 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0, + }; + auto _payload4717 = _record4193; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.sheepRegrowWoolEvent(_payload4717); + break; + } + case _Tag4520.slimeSplitEvent: { + wit.pumpkin.plugin.event.common.SlimeSplitEventData _record4195 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + count: cast(int)(*(cast(uint*)(arg0 + 20))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4718 = _record4195; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.slimeSplitEvent(_payload4718); + break; + } + case _Tag4520.striderTemperatureChangeEvent: { + wit.pumpkin.plugin.event.common.StriderTemperatureChangeEventData _record4197 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + isShivering: (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 21)))) != 0, + }; + auto _payload4719 = _record4197; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.striderTemperatureChangeEvent(_payload4719); + break; + } + case _Tag4520.villagerAcquireTradeEvent: { + wit.pumpkin.plugin.event.common.VillagerAcquireTradeEventData _record4199 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + recipeIndex: cast(int)(*(cast(uint*)(arg0 + 20))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4720 = _record4199; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.villagerAcquireTradeEvent(_payload4720); + break; + } + case _Tag4520.villagerCareerChangeEvent: { + auto _len4201 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4201 = _len4201 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4201) deallocate ~= cast()_ptr4201; + auto _list4202 = WitString(_ptr4201[0.._len4201]); + auto _len4203 = *(cast(size_t*)(arg0 + (16+4*size_t.sizeof))); + auto _ptr4203 = _len4203 ? cast(char*)(*(cast(void**)(arg0 + (16+3*size_t.sizeof)))) : null; + if (_len4203) deallocate ~= cast()_ptr4203; + auto _list4204 = WitString(_ptr4203[0.._len4203]); + wit.pumpkin.plugin.event.common.VillagerCareerChangeEventData _record4205 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + profession: _list4202, + reason: _list4204, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+5*size_t.sizeof))))) != 0, + }; + auto _payload4721 = _record4205; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.villagerCareerChangeEvent(_payload4721); + break; + } + case _Tag4520.villagerReplenishTradeEvent: { + wit.pumpkin.plugin.event.common.VillagerReplenishTradeEventData _record4207 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + restockQuantity: cast(int)(*(cast(uint*)(arg0 + 20))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4722 = _record4207; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.villagerReplenishTradeEvent(_payload4722); + break; + } + case _Tag4520.wardenAngerChangeEvent: { + wit.pumpkin.plugin.event.common.WardenAngerChangeEventData _record4209 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + targetId: cast(int)(*(cast(uint*)(arg0 + 20))), + oldAnger: cast(int)(*(cast(uint*)(arg0 + 24))), + newAnger: cast(int)(*(cast(uint*)(arg0 + 28))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0, + }; + auto _payload4723 = _record4209; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.wardenAngerChangeEvent(_payload4723); + break; + } + case _Tag4520.areaEffectCloudApplyEvent: { + auto _len4211 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4211 = _len4211 ? cast(int*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4211) deallocate ~= cast()_ptr4211; + auto _list4212 = WitList!(int)(_ptr4211[0.._len4211]); + wit.pumpkin.plugin.event.common.AreaEffectCloudApplyEventData _record4213 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + affectedEntities: _list4212, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + }; + auto _payload4724 = _record4213; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.areaEffectCloudApplyEvent(_payload4724); + break; + } + case _Tag4520.arrowBodyCountChangeEvent: { + wit.pumpkin.plugin.event.common.ArrowBodyCountChangeEventData _record4215 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + oldAmount: *(cast(uint*)(arg0 + 20)), + newAmount: *(cast(uint*)(arg0 + 24)), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 28)))) != 0, + }; + auto _payload4725 = _record4215; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.arrowBodyCountChangeEvent(_payload4725); + break; + } + case _Tag4520.batToggleSleepEvent: { + wit.pumpkin.plugin.event.common.BatToggleSleepEventData _record4217 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + isAwake: (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 21)))) != 0, + }; + auto _payload4726 = _record4217; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.batToggleSleepEvent(_payload4726); + break; + } + case _Tag4520.creeperPowerEvent: { + Option!(int) _option4221 = void; + bool _isSome4221 = (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0; + if (_isSome4221) { + + _option4221 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + 24)))); + } else { + _option4221 = Option!(int).makeNone; + } + auto _len4222 = *(cast(size_t*)(arg0 + (24+2*size_t.sizeof))); + auto _ptr4222 = _len4222 ? cast(char*)(*(cast(void**)(arg0 + (24+1*size_t.sizeof)))) : null; + if (_len4222) deallocate ~= cast()_ptr4222; + auto _list4223 = WitString(_ptr4222[0.._len4222]); + wit.pumpkin.plugin.event.common.CreeperPowerEventData _record4224 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + lightningId: _option4221, + cause: _list4223, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (24+3*size_t.sizeof))))) != 0, + }; + auto _payload4727 = _record4224; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.creeperPowerEvent(_payload4727); + break; + } + case _Tag4520.entityCombustByBlockEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4226 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + wit.pumpkin.plugin.event.common.EntityCombustByBlockEventData _record4227 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + combuster: _record4226, + duration: *(cast(float*)(arg0 + 32)), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 36)))) != 0, + }; + auto _payload4728 = _record4227; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityCombustByBlockEvent(_payload4728); + break; + } + case _Tag4520.entityCombustByEntityEvent: { + wit.pumpkin.plugin.event.common.EntityCombustByEntityEventData _record4229 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + combusterId: cast(int)(*(cast(uint*)(arg0 + 20))), + duration: *(cast(float*)(arg0 + 24)), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 28)))) != 0, + }; + auto _payload4729 = _record4229; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityCombustByEntityEvent(_payload4729); + break; + } + case _Tag4520.entityKnockbackByEntityEvent: { + wit.pumpkin.plugin.event.common.EntityKnockbackByEntityEventData _record4231 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + hitById: cast(int)(*(cast(uint*)(arg0 + 20))), + force: *(cast(double*)(arg0 + 24)), + x: *(cast(double*)(arg0 + 32)), + z: *(cast(double*)(arg0 + 40)), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 48)))) != 0, + }; + auto _payload4730 = _record4231; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityKnockbackByEntityEvent(_payload4730); + break; + } + case _Tag4520.entityPortalEnterEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4233 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + wit.pumpkin.plugin.event.common.EntityPortalEnterEventData _record4234 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + location: _record4233, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0, + }; + auto _payload4731 = _record4234; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityPortalEnterEvent(_payload4731); + break; + } + case _Tag4520.entityPortalExitEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4236 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + Option!(wit.pumpkin.plugin.event.common.BlockPos) _option4240 = void; + bool _isSome4240 = (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0; + if (_isSome4240) { + wit.pumpkin.plugin.common.common.BlockPos _record4239 = { + x: cast(int)(*(cast(uint*)(arg0 + 36))), + y: cast(int)(*(cast(uint*)(arg0 + 40))), + z: cast(int)(*(cast(uint*)(arg0 + 44))), + }; + + _option4240 = Option!(wit.pumpkin.plugin.event.common.BlockPos).makeSome(_record4239); + } else { + _option4240 = Option!(wit.pumpkin.plugin.event.common.BlockPos).makeNone; + } + wit.pumpkin.plugin.event.common.EntityPortalExitEventData _record4241 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + fromPos: _record4236, + toPos: _option4240, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 48)))) != 0, + }; + auto _payload4732 = _record4241; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityPortalExitEvent(_payload4732); + break; + } + case _Tag4520.entityRemoveEvent: { + auto _len4243 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4243 = _len4243 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4243) deallocate ~= cast()_ptr4243; + auto _list4244 = WitString(_ptr4243[0.._len4243]); + wit.pumpkin.plugin.event.common.EntityRemoveEventData _record4245 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + cause: _list4244, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + }; + auto _payload4733 = _record4245; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityRemoveEvent(_payload4733); + break; + } + case _Tag4520.entityTargetBlockEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4247 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + wit.pumpkin.plugin.event.common.EntityTargetBlockEventData _record4248 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + blockPos: _record4247, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0, + }; + auto _payload4734 = _record4248; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityTargetBlockEvent(_payload4734); + break; + } + case _Tag4520.entityUnleashEvent: { + auto _len4250 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4250 = _len4250 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4250) deallocate ~= cast()_ptr4250; + auto _list4251 = WitString(_ptr4250[0.._len4250]); + wit.pumpkin.plugin.event.common.EntityUnleashEventData _record4252 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + reason: _list4251, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + }; + auto _payload4735 = _record4252; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.entityUnleashEvent(_payload4735); + break; + } + case _Tag4520.expBottleEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4254 = { + x: cast(int)(*(cast(uint*)(arg0 + 24))), + y: cast(int)(*(cast(uint*)(arg0 + 28))), + z: cast(int)(*(cast(uint*)(arg0 + 32))), + }; + wit.pumpkin.plugin.event.common.ExpBottleEventData _record4255 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + experience: cast(int)(*(cast(uint*)(arg0 + 20))), + location: _record4254, + showEffect: (cast(uint)(*(cast(ubyte*)(arg0 + 36)))) != 0, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 37)))) != 0, + }; + auto _payload4736 = _record4255; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.expBottleEvent(_payload4736); + break; + } + case _Tag4520.horseJumpEvent: { + wit.pumpkin.plugin.event.common.HorseJumpEventData _record4257 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + power: *(cast(float*)(arg0 + 20)), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4737 = _record4257; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.horseJumpEvent(_payload4737); + break; + } + case _Tag4520.lingeringPotionSplashEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4259 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + auto _len4260 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + auto _ptr4260 = _len4260 ? cast(char*)(*(cast(void**)(arg0 + 32))) : null; + if (_len4260) deallocate ~= cast()_ptr4260; + auto _list4261 = WitString(_ptr4260[0.._len4260]); + wit.pumpkin.plugin.event.common.LingeringPotionSplashEventData _record4262 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + location: _record4259, + potionItem: _list4261, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (32+2*size_t.sizeof))))) != 0, + }; + auto _payload4738 = _record4262; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.lingeringPotionSplashEvent(_payload4738); + break; + } + case _Tag4520.pigZapEvent: { + wit.pumpkin.plugin.event.common.PigZapEventData _record4264 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + lightningId: cast(int)(*(cast(uint*)(arg0 + 20))), + pigZombieId: cast(int)(*(cast(uint*)(arg0 + 24))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 28)))) != 0, + }; + auto _payload4739 = _record4264; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.pigZapEvent(_payload4739); + break; + } + case _Tag4520.pigZombieAngerEvent: { + Option!(int) _option4268 = void; + bool _isSome4268 = (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0; + if (_isSome4268) { + + _option4268 = Option!(int).makeSome(cast(int)(*(cast(uint*)(arg0 + 24)))); + } else { + _option4268 = Option!(int).makeNone; + } + wit.pumpkin.plugin.event.common.PigZombieAngerEventData _record4269 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + targetId: _option4268, + newAnger: cast(int)(*(cast(uint*)(arg0 + 28))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0, + }; + auto _payload4740 = _record4269; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.pigZombieAngerEvent(_payload4740); + break; + } + case _Tag4520.potionSplashEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4271 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + auto _len4272 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + auto _ptr4272 = _len4272 ? cast(char*)(*(cast(void**)(arg0 + 32))) : null; + if (_len4272) deallocate ~= cast()_ptr4272; + auto _list4273 = WitString(_ptr4272[0.._len4272]); + auto _len4274 = *(cast(size_t*)(arg0 + (32+3*size_t.sizeof))); + auto _ptr4274 = _len4274 ? cast(int*)(*(cast(void**)(arg0 + (32+2*size_t.sizeof)))) : null; + if (_len4274) deallocate ~= cast()_ptr4274; + auto _list4275 = WitList!(int)(_ptr4274[0.._len4274]); + wit.pumpkin.plugin.event.common.PotionSplashEventData _record4276 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + location: _record4271, + potionItem: _list4273, + affectedEntities: _list4275, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (32+4*size_t.sizeof))))) != 0, + }; + auto _payload4741 = _record4276; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.potionSplashEvent(_payload4741); + break; + } + case _Tag4520.spawnerSpawnEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4278 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + wit.pumpkin.plugin.event.common.SpawnerSpawnEventData _record4279 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + spawnerPos: _record4278, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0, + }; + auto _payload4742 = _record4279; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.spawnerSpawnEvent(_payload4742); + break; + } + case _Tag4520.trialSpawnerSpawnEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4281 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + wit.pumpkin.plugin.event.common.TrialSpawnerSpawnEventData _record4282 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + spawnerPos: _record4281, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0, + }; + auto _payload4743 = _record4282; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.trialSpawnerSpawnEvent(_payload4743); + break; + } + case _Tag4520.villagerReputationChangeEvent: { + wit.pumpkin.plugin.event.common.VillagerReputationChangeEventData _record4284 = { + entityId: cast(int)(*(cast(uint*)(arg0 + 16))), + targetId: cast(int)(*(cast(uint*)(arg0 + 20))), + reputationChange: cast(int)(*(cast(uint*)(arg0 + 24))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 28)))) != 0, + }; + auto _payload4744 = _record4284; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.villagerReputationChangeEvent(_payload4744); + break; + } + case _Tag4520.asyncPlayerChatEvent: { + auto _handle4286 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len4287 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4287 = _len4287 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4287) deallocate ~= cast()_ptr4287; + auto _list4288 = WitString(_ptr4287[0.._len4287]); + auto _handle4289 = wit.pumpkin.plugin.event.imports.TextComponent(*(cast(uint*)(arg0 + (16+3*size_t.sizeof)))); + wit.pumpkin.plugin.event.imports.AsyncPlayerChatEventData _record4290 = { + player: _handle4286, + message: _list4288, + format: _handle4289, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (20+3*size_t.sizeof))))) != 0, + }; + auto _payload4745 = _record4290; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.asyncPlayerChatEvent(_payload4745); + break; + } + case _Tag4520.asyncPlayerPreLoginEvent: { + auto _len4292 = *(cast(size_t*)(arg0 + (16+1*size_t.sizeof))); + auto _ptr4292 = _len4292 ? cast(char*)(*(cast(void**)(arg0 + 16))) : null; + if (_len4292) deallocate ~= cast()_ptr4292; + auto _list4293 = WitString(_ptr4292[0.._len4292]); + auto _len4294 = *(cast(size_t*)(arg0 + (16+3*size_t.sizeof))); + auto _ptr4294 = _len4294 ? cast(char*)(*(cast(void**)(arg0 + (16+2*size_t.sizeof)))) : null; + if (_len4294) deallocate ~= cast()_ptr4294; + auto _list4295 = WitString(_ptr4294[0.._len4294]); + auto _len4296 = *(cast(size_t*)(arg0 + (16+5*size_t.sizeof))); + auto _ptr4296 = _len4296 ? cast(char*)(*(cast(void**)(arg0 + (16+4*size_t.sizeof)))) : null; + if (_len4296) deallocate ~= cast()_ptr4296; + auto _list4297 = WitString(_ptr4296[0.._len4296]); + auto _handle4298 = wit.pumpkin.plugin.event.imports.TextComponent(*(cast(uint*)(arg0 + (16+6*size_t.sizeof)))); + wit.pumpkin.plugin.event.imports.AsyncPlayerPreLoginEventData _record4299 = { + playerName: _list4293, + playerUuid: _list4295, + ipAddress: _list4297, + kickMessage: _handle4298, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (20+6*size_t.sizeof))))) != 0, + }; + auto _payload4746 = _record4299; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.asyncPlayerPreLoginEvent(_payload4746); + break; + } + case _Tag4520.playerAdvancementDoneEvent: { + auto _handle4301 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len4302 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4302 = _len4302 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4302) deallocate ~= cast()_ptr4302; + auto _list4303 = WitString(_ptr4302[0.._len4302]); + wit.pumpkin.plugin.event.imports.PlayerAdvancementDoneEventData _record4304 = { + player: _handle4301, + advancementId: _list4303, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + }; + auto _payload4747 = _record4304; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerAdvancementDoneEvent(_payload4747); + break; + } + case _Tag4520.playerAnimationEvent: { + auto _handle4306 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len4307 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4307 = _len4307 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4307) deallocate ~= cast()_ptr4307; + auto _list4308 = WitString(_ptr4307[0.._len4307]); + wit.pumpkin.plugin.event.imports.PlayerAnimationEventData _record4309 = { + player: _handle4306, + animationType: _list4308, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + }; + auto _payload4748 = _record4309; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerAnimationEvent(_payload4748); + break; + } + case _Tag4520.playerArmorStandManipulateEvent: { + auto _handle4311 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.PlayerArmorStandManipulateEventData _record4312 = { + player: _handle4311, + armorStandId: cast(int)(*(cast(uint*)(arg0 + 20))), + slot: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 24)))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 25)))) != 0, + }; + auto _payload4749 = _record4312; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerArmorStandManipulateEvent(_payload4749); + break; + } + case _Tag4520.playerBucketEntityEvent: { + auto _handle4314 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len4315 = *(cast(size_t*)(arg0 + (24+1*size_t.sizeof))); + auto _ptr4315 = _len4315 ? cast(char*)(*(cast(void**)(arg0 + 24))) : null; + if (_len4315) deallocate ~= cast()_ptr4315; + auto _list4316 = WitString(_ptr4315[0.._len4315]); + wit.pumpkin.plugin.event.imports.PlayerBucketEntityEventData _record4317 = { + player: _handle4314, + entityId: cast(int)(*(cast(uint*)(arg0 + 20))), + bucketItem: _list4316, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (24+2*size_t.sizeof))))) != 0, + }; + auto _payload4750 = _record4317; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerBucketEntityEvent(_payload4750); + break; + } + case _Tag4520.playerChangedWorldEvent: { + auto _handle4319 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _handle4320 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 20))); + auto _handle4321 = wit.pumpkin.plugin.event.imports.World(*(cast(uint*)(arg0 + 24))); + wit.pumpkin.plugin.event.imports.PlayerChangedWorldEventData _record4322 = { + player: _handle4319, + fromWorld: _handle4320, + toWorld: _handle4321, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 28)))) != 0, + }; + auto _payload4751 = _record4322; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerChangedWorldEvent(_payload4751); + break; + } + case _Tag4520.playerChannelEvent: { + auto _handle4324 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len4325 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4325 = _len4325 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4325) deallocate ~= cast()_ptr4325; + auto _list4326 = WitString(_ptr4325[0.._len4325]); + wit.pumpkin.plugin.event.imports.PlayerChannelEventData _record4327 = { + player: _handle4324, + channel: _list4326, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + }; + auto _payload4752 = _record4327; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerChannelEvent(_payload4752); + break; + } + case _Tag4520.playerCommandPreprocessEvent: { + auto _handle4329 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len4330 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4330 = _len4330 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4330) deallocate ~= cast()_ptr4330; + auto _list4331 = WitString(_ptr4330[0.._len4330]); + wit.pumpkin.plugin.event.imports.PlayerCommandPreprocessEventData _record4332 = { + player: _handle4329, + command: _list4331, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + }; + auto _payload4753 = _record4332; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerCommandPreprocessEvent(_payload4753); + break; + } + case _Tag4520.playerEditBookEvent: { + auto _handle4334 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _listSrcPtr4338 = *(cast(void**)(arg0 + 24)); + auto _listLen4338 = *(cast(size_t*)(arg0 + (24+1*size_t.sizeof))); + auto _list4338 = _listLen4338 ? wit.common.mallocSlice!(WitString)(_listLen4338) : []; + assert(!_listLen4338 || _list4338.ptr); + if (_listLen4338) deallocate ~= cast(void*)_list4338.ptr; + foreach (_elem4335_idx, ref _elem4335; _list4338) { + const auto _base4335 = _listSrcPtr4338 + _elem4335_idx * (2*size_t.sizeof); + auto _len4336 = *(cast(size_t*)(_base4335 + size_t.sizeof)); + auto _ptr4336 = _len4336 ? cast(char*)(*(cast(void**)(_base4335 + 0))) : null; + if (_len4336) deallocate ~= cast()_ptr4336; + auto _list4337 = WitString(_ptr4336[0.._len4336]); + _elem4335 = _list4337; + } + if (_listLen4338) deallocate ~= _listSrcPtr4338; + auto _witList4339 = WitList!(WitString)(_list4338); + Option!(WitString) _option4344 = void; + bool _isSome4344 = (cast(uint)(*(cast(ubyte*)(arg0 + (24+2*size_t.sizeof))))) != 0; + if (_isSome4344) { + auto _len4342 = *(cast(size_t*)(arg0 + (24+4*size_t.sizeof))); + auto _ptr4342 = _len4342 ? cast(char*)(*(cast(void**)(arg0 + (24+3*size_t.sizeof)))) : null; + if (_len4342) deallocate ~= cast()_ptr4342; + auto _list4343 = WitString(_ptr4342[0.._len4342]); + + _option4344 = Option!(WitString).makeSome(_list4343); + } else { + _option4344 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.event.imports.PlayerEditBookEventData _record4345 = { + player: _handle4334, + slot: *(cast(uint*)(arg0 + 20)), + pages: _witList4339, + title: _option4344, + signing: (cast(uint)(*(cast(ubyte*)(arg0 + (24+5*size_t.sizeof))))) != 0, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (25+5*size_t.sizeof))))) != 0, + }; + auto _payload4754 = _record4345; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerEditBookEvent(_payload4754); + break; + } + case _Tag4520.playerElytraBoostEvent: { + auto _handle4347 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.PlayerElytraBoostEventData _record4348 = { + player: _handle4347, + fireworkId: cast(int)(*(cast(uint*)(arg0 + 20))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4755 = _record4348; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerElytraBoostEvent(_payload4755); + break; + } + case _Tag4520.playerExpCooldownChangeEvent: { + auto _handle4350 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.PlayerExpCooldownChangeEventData _record4351 = { + player: _handle4350, + newCooldown: cast(int)(*(cast(uint*)(arg0 + 20))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4756 = _record4351; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerExpCooldownChangeEvent(_payload4756); + break; + } + case _Tag4520.playerHarvestBlockEvent: { + auto _handle4353 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.common.common.BlockPos _record4354 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + auto _len4355 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + auto _ptr4355 = _len4355 ? cast(wit.pumpkin.plugin.event.imports.ItemStack*)(*(cast(void**)(arg0 + 32))) : null; + if (_len4355) deallocate ~= cast()_ptr4355; + auto _list4356 = WitList!(wit.pumpkin.plugin.event.imports.ItemStack)(_ptr4355[0.._len4355]); + wit.pumpkin.plugin.event.imports.PlayerHarvestBlockEventData _record4357 = { + player: _handle4353, + blockPos: _record4354, + harvestedItems: _list4356, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (32+2*size_t.sizeof))))) != 0, + }; + auto _payload4757 = _record4357; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerHarvestBlockEvent(_payload4757); + break; + } + case _Tag4520.playerHideEntityEvent: { + auto _handle4359 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.PlayerHideEntityEventData _record4360 = { + player: _handle4359, + entityId: cast(int)(*(cast(uint*)(arg0 + 20))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4758 = _record4360; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerHideEntityEvent(_payload4758); + break; + } + case _Tag4520.playerItemBreakEvent: { + auto _handle4362 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len4363 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4363 = _len4363 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4363) deallocate ~= cast()_ptr4363; + auto _list4364 = WitString(_ptr4363[0.._len4363]); + wit.pumpkin.plugin.event.imports.PlayerItemBreakEventData _record4365 = { + player: _handle4362, + itemName: _list4364, + }; + auto _payload4759 = _record4365; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerItemBreakEvent(_payload4759); + break; + } + case _Tag4520.playerItemMendEvent: { + auto _handle4367 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len4368 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4368 = _len4368 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4368) deallocate ~= cast()_ptr4368; + auto _list4369 = WitString(_ptr4368[0.._len4368]); + wit.pumpkin.plugin.event.imports.PlayerItemMendEventData _record4370 = { + player: _handle4367, + itemName: _list4369, + repairAmount: cast(int)(*(cast(uint*)(arg0 + (16+3*size_t.sizeof)))), + expConsumed: cast(int)(*(cast(uint*)(arg0 + (20+3*size_t.sizeof)))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (24+3*size_t.sizeof))))) != 0, + }; + auto _payload4760 = _record4370; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerItemMendEvent(_payload4760); + break; + } + case _Tag4520.playerKickEvent: { + auto _handle4372 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len4373 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4373 = _len4373 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4373) deallocate ~= cast()_ptr4373; + auto _list4374 = WitString(_ptr4373[0.._len4373]); + wit.pumpkin.plugin.event.imports.PlayerKickEventData _record4375 = { + player: _handle4372, + reason: _list4374, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + }; + auto _payload4761 = _record4375; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerKickEvent(_payload4761); + break; + } + case _Tag4520.playerLeashEntityEvent: { + auto _handle4377 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.PlayerLeashEntityEventData _record4378 = { + player: _handle4377, + entityId: cast(int)(*(cast(uint*)(arg0 + 20))), + holderId: cast(int)(*(cast(uint*)(arg0 + 24))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 28)))) != 0, + }; + auto _payload4762 = _record4378; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerLeashEntityEvent(_payload4762); + break; + } + case _Tag4520.playerLevelChangeEvent: { + auto _handle4380 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.PlayerLevelChangeEventData _record4381 = { + player: _handle4380, + oldLevel: cast(int)(*(cast(uint*)(arg0 + 20))), + newLevel: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + auto _payload4763 = _record4381; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerLevelChangeEvent(_payload4763); + break; + } + case _Tag4520.playerLocaleChangeEvent: { + auto _handle4383 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len4384 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4384 = _len4384 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4384) deallocate ~= cast()_ptr4384; + auto _list4385 = WitString(_ptr4384[0.._len4384]); + wit.pumpkin.plugin.event.imports.PlayerLocaleChangeEventData _record4386 = { + player: _handle4383, + newLocale: _list4385, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + }; + auto _payload4764 = _record4386; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerLocaleChangeEvent(_payload4764); + break; + } + case _Tag4520.playerNameEntityEvent: { + auto _handle4388 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _handle4389 = wit.pumpkin.plugin.event.imports.TextComponent(*(cast(uint*)(arg0 + 24))); + wit.pumpkin.plugin.event.imports.PlayerNameEntityEventData _record4390 = { + player: _handle4388, + entityId: cast(int)(*(cast(uint*)(arg0 + 20))), + name: _handle4389, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 28)))) != 0, + }; + auto _payload4765 = _record4390; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerNameEntityEvent(_payload4765); + break; + } + case _Tag4520.playerOpenSignEvent: { + auto _handle4392 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.common.common.BlockPos _record4393 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + wit.pumpkin.plugin.event.imports.PlayerOpenSignEventData _record4394 = { + player: _handle4392, + blockPos: _record4393, + isFront: (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 33)))) != 0, + }; + auto _payload4766 = _record4394; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerOpenSignEvent(_payload4766); + break; + } + case _Tag4520.playerPortalEvent: { + auto _handle4396 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.common.common.BlockPos _record4397 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + Option!(wit.pumpkin.plugin.event.common.BlockPos) _option4401 = void; + bool _isSome4401 = (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0; + if (_isSome4401) { + wit.pumpkin.plugin.common.common.BlockPos _record4400 = { + x: cast(int)(*(cast(uint*)(arg0 + 36))), + y: cast(int)(*(cast(uint*)(arg0 + 40))), + z: cast(int)(*(cast(uint*)(arg0 + 44))), + }; + + _option4401 = Option!(wit.pumpkin.plugin.event.common.BlockPos).makeSome(_record4400); + } else { + _option4401 = Option!(wit.pumpkin.plugin.event.common.BlockPos).makeNone; + } + wit.pumpkin.plugin.event.imports.PlayerPortalEventData _record4402 = { + player: _handle4396, + fromPos: _record4397, + toPos: _option4401, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 48)))) != 0, + }; + auto _payload4767 = _record4402; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerPortalEvent(_payload4767); + break; + } + case _Tag4520.playerPreLoginEvent: { + auto _len4404 = *(cast(size_t*)(arg0 + (16+1*size_t.sizeof))); + auto _ptr4404 = _len4404 ? cast(char*)(*(cast(void**)(arg0 + 16))) : null; + if (_len4404) deallocate ~= cast()_ptr4404; + auto _list4405 = WitString(_ptr4404[0.._len4404]); + auto _len4406 = *(cast(size_t*)(arg0 + (16+3*size_t.sizeof))); + auto _ptr4406 = _len4406 ? cast(char*)(*(cast(void**)(arg0 + (16+2*size_t.sizeof)))) : null; + if (_len4406) deallocate ~= cast()_ptr4406; + auto _list4407 = WitString(_ptr4406[0.._len4406]); + auto _len4408 = *(cast(size_t*)(arg0 + (16+5*size_t.sizeof))); + auto _ptr4408 = _len4408 ? cast(char*)(*(cast(void**)(arg0 + (16+4*size_t.sizeof)))) : null; + if (_len4408) deallocate ~= cast()_ptr4408; + auto _list4409 = WitString(_ptr4408[0.._len4408]); + auto _handle4410 = wit.pumpkin.plugin.event.imports.TextComponent(*(cast(uint*)(arg0 + (16+6*size_t.sizeof)))); + wit.pumpkin.plugin.event.imports.PlayerPreLoginEventData _record4411 = { + playerName: _list4405, + playerUuid: _list4407, + ipAddress: _list4409, + kickMessage: _handle4410, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (20+6*size_t.sizeof))))) != 0, + }; + auto _payload4768 = _record4411; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerPreLoginEvent(_payload4768); + break; + } + case _Tag4520.playerRiptideEvent: { + auto _handle4413 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len4414 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4414 = _len4414 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4414) deallocate ~= cast()_ptr4414; + auto _list4415 = WitString(_ptr4414[0.._len4414]); + wit.pumpkin.plugin.event.imports.PlayerRiptideEventData _record4416 = { + player: _handle4413, + itemName: _list4415, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + }; + auto _payload4769 = _record4416; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerRiptideEvent(_payload4769); + break; + } + case _Tag4520.playerShearEntityEvent: { + auto _handle4418 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.PlayerShearEntityEventData _record4419 = { + player: _handle4418, + entityId: cast(int)(*(cast(uint*)(arg0 + 20))), + hand: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 24)))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 25)))) != 0, + }; + auto _payload4770 = _record4419; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerShearEntityEvent(_payload4770); + break; + } + case _Tag4520.playerShowEntityEvent: { + auto _handle4421 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.PlayerShowEntityEventData _record4422 = { + player: _handle4421, + entityId: cast(int)(*(cast(uint*)(arg0 + 20))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4771 = _record4422; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerShowEntityEvent(_payload4771); + break; + } + case _Tag4520.playerSpawnChangeEvent: { + auto _handle4424 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + Option!(wit.pumpkin.plugin.event.common.BlockPos) _option4428 = void; + bool _isSome4428 = (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0; + if (_isSome4428) { + wit.pumpkin.plugin.common.common.BlockPos _record4427 = { + x: cast(int)(*(cast(uint*)(arg0 + 24))), + y: cast(int)(*(cast(uint*)(arg0 + 28))), + z: cast(int)(*(cast(uint*)(arg0 + 32))), + }; + + _option4428 = Option!(wit.pumpkin.plugin.event.common.BlockPos).makeSome(_record4427); + } else { + _option4428 = Option!(wit.pumpkin.plugin.event.common.BlockPos).makeNone; + } + wit.pumpkin.plugin.event.imports.PlayerSpawnChangeEventData _record4429 = { + player: _handle4424, + newSpawn: _option4428, + forced: (cast(uint)(*(cast(ubyte*)(arg0 + 36)))) != 0, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 37)))) != 0, + }; + auto _payload4772 = _record4429; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerSpawnChangeEvent(_payload4772); + break; + } + case _Tag4520.playerStatisticIncrementEvent: { + auto _handle4431 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len4432 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4432 = _len4432 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4432) deallocate ~= cast()_ptr4432; + auto _list4433 = WitString(_ptr4432[0.._len4432]); + wit.pumpkin.plugin.event.imports.PlayerStatisticIncrementEventData _record4434 = { + player: _handle4431, + statisticId: _list4433, + amount: cast(int)(*(cast(uint*)(arg0 + (16+3*size_t.sizeof)))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (20+3*size_t.sizeof))))) != 0, + }; + auto _payload4773 = _record4434; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerStatisticIncrementEvent(_payload4773); + break; + } + case _Tag4520.playerSwapHandsEvent: { + auto _handle4436 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.PlayerSwapHandsEventData _record4437 = { + player: _handle4436, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 20)))) != 0, + }; + auto _payload4774 = _record4437; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerSwapHandsEvent(_payload4774); + break; + } + case _Tag4520.playerTakeLecternBookEvent: { + auto _handle4439 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.common.common.BlockPos _record4440 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + auto _handle4441 = wit.pumpkin.plugin.event.imports.ItemStack(*(cast(uint*)(arg0 + 32))); + wit.pumpkin.plugin.event.imports.PlayerTakeLecternBookEventData _record4442 = { + player: _handle4439, + blockPos: _record4440, + book: _handle4441, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 36)))) != 0, + }; + auto _payload4775 = _record4442; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerTakeLecternBookEvent(_payload4775); + break; + } + case _Tag4520.playerUnleashEntityEvent: { + auto _handle4444 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.PlayerUnleashEntityEventData _record4445 = { + player: _handle4444, + entityId: cast(int)(*(cast(uint*)(arg0 + 20))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4776 = _record4445; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerUnleashEntityEvent(_payload4776); + break; + } + case _Tag4520.playerVelocityEvent: { + auto _handle4447 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _tuple4448 = wit.pumpkin.plugin.common.common.Position( + *(cast(double*)(arg0 + 24)), + *(cast(double*)(arg0 + 32)), + *(cast(double*)(arg0 + 40)), + ); + wit.pumpkin.plugin.event.imports.PlayerVelocityEventData _record4449 = { + player: _handle4447, + velocity: _tuple4448, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 48)))) != 0, + }; + auto _payload4777 = _record4449; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerVelocityEvent(_payload4777); + break; + } + case _Tag4520.playerInputEvent: { + auto _handle4451 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len4452 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4452 = _len4452 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4452) deallocate ~= cast()_ptr4452; + auto _list4453 = WitString(_ptr4452[0.._len4452]); + wit.pumpkin.plugin.event.imports.PlayerInputEventData _record4454 = { + player: _handle4451, + input: _list4453, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + }; + auto _payload4778 = _record4454; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerInputEvent(_payload4778); + break; + } + case _Tag4520.playerInteractAtEntityEvent: { + auto _handle4456 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.PlayerInteractAtEntityEventData _record4457 = { + player: _handle4456, + entityId: cast(int)(*(cast(uint*)(arg0 + 20))), + clickedX: *(cast(double*)(arg0 + 24)), + clickedY: *(cast(double*)(arg0 + 32)), + clickedZ: *(cast(double*)(arg0 + 40)), + hand: cast(ubyte)(cast(uint)(*(cast(ubyte*)(arg0 + 48)))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 49)))) != 0, + }; + auto _payload4779 = _record4457; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerInteractAtEntityEvent(_payload4779); + break; + } + case _Tag4520.playerLinksSendEvent: { + auto _handle4459 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _listSrcPtr4463 = *(cast(void**)(arg0 + (16+1*size_t.sizeof))); + auto _listLen4463 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _list4463 = _listLen4463 ? wit.common.mallocSlice!(WitString)(_listLen4463) : []; + assert(!_listLen4463 || _list4463.ptr); + if (_listLen4463) deallocate ~= cast(void*)_list4463.ptr; + foreach (_elem4460_idx, ref _elem4460; _list4463) { + const auto _base4460 = _listSrcPtr4463 + _elem4460_idx * (2*size_t.sizeof); + auto _len4461 = *(cast(size_t*)(_base4460 + size_t.sizeof)); + auto _ptr4461 = _len4461 ? cast(char*)(*(cast(void**)(_base4460 + 0))) : null; + if (_len4461) deallocate ~= cast()_ptr4461; + auto _list4462 = WitString(_ptr4461[0.._len4461]); + _elem4460 = _list4462; + } + if (_listLen4463) deallocate ~= _listSrcPtr4463; + auto _witList4464 = WitList!(WitString)(_list4463); + wit.pumpkin.plugin.event.imports.PlayerLinksSendEventData _record4465 = { + player: _handle4459, + links: _witList4464, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + }; + auto _payload4780 = _record4465; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerLinksSendEvent(_payload4780); + break; + } + case _Tag4520.playerPickupArrowEvent: { + auto _handle4467 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + wit.pumpkin.plugin.event.imports.PlayerPickupArrowEventData _record4468 = { + player: _handle4467, + arrowId: cast(int)(*(cast(uint*)(arg0 + 20))), + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) != 0, + }; + auto _payload4781 = _record4468; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerPickupArrowEvent(_payload4781); + break; + } + case _Tag4520.playerRecipeBookClickEvent: { + auto _handle4470 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len4471 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4471 = _len4471 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4471) deallocate ~= cast()_ptr4471; + auto _list4472 = WitString(_ptr4471[0.._len4471]); + wit.pumpkin.plugin.event.imports.PlayerRecipeBookClickEventData _record4473 = { + player: _handle4470, + recipeId: _list4472, + makeAll: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (17+3*size_t.sizeof))))) != 0, + }; + auto _payload4782 = _record4473; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerRecipeBookClickEvent(_payload4782); + break; + } + case _Tag4520.playerRecipeBookSettingsChangeEvent: { + auto _handle4475 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len4476 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4476 = _len4476 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4476) deallocate ~= cast()_ptr4476; + auto _list4477 = WitString(_ptr4476[0.._len4476]); + wit.pumpkin.plugin.event.imports.PlayerRecipeBookSettingsChangeEventData _record4478 = { + player: _handle4475, + bookType: _list4477, + isOpen: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + isFiltering: (cast(uint)(*(cast(ubyte*)(arg0 + (17+3*size_t.sizeof))))) != 0, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (18+3*size_t.sizeof))))) != 0, + }; + auto _payload4783 = _record4478; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerRecipeBookSettingsChangeEvent(_payload4783); + break; + } + case _Tag4520.playerRecipeDiscoverEvent: { + auto _handle4480 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len4481 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4481 = _len4481 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4481) deallocate ~= cast()_ptr4481; + auto _list4482 = WitString(_ptr4481[0.._len4481]); + wit.pumpkin.plugin.event.imports.PlayerRecipeDiscoverEventData _record4483 = { + player: _handle4480, + recipeId: _list4482, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + }; + auto _payload4784 = _record4483; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerRecipeDiscoverEvent(_payload4784); + break; + } + case _Tag4520.playerRegisterChannelEvent: { + auto _handle4485 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len4486 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4486 = _len4486 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4486) deallocate ~= cast()_ptr4486; + auto _list4487 = WitString(_ptr4486[0.._len4486]); + wit.pumpkin.plugin.event.imports.PlayerRegisterChannelEventData _record4488 = { + player: _handle4485, + channel: _list4487, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + }; + auto _payload4785 = _record4488; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerRegisterChannelEvent(_payload4785); + break; + } + case _Tag4520.playerResourcePackStatusEvent: { + auto _handle4490 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len4491 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4491 = _len4491 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4491) deallocate ~= cast()_ptr4491; + auto _list4492 = WitString(_ptr4491[0.._len4491]); + auto _len4493 = *(cast(size_t*)(arg0 + (16+4*size_t.sizeof))); + auto _ptr4493 = _len4493 ? cast(char*)(*(cast(void**)(arg0 + (16+3*size_t.sizeof)))) : null; + if (_len4493) deallocate ~= cast()_ptr4493; + auto _list4494 = WitString(_ptr4493[0.._len4493]); + wit.pumpkin.plugin.event.imports.PlayerResourcePackStatusEventData _record4495 = { + player: _handle4490, + packId: _list4492, + status: _list4494, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+5*size_t.sizeof))))) != 0, + }; + auto _payload4786 = _record4495; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerResourcePackStatusEvent(_payload4786); + break; + } + case _Tag4520.playerSpawnLocationEvent: { + auto _handle4497 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _tuple4498 = wit.pumpkin.plugin.common.common.Position( + *(cast(double*)(arg0 + 24)), + *(cast(double*)(arg0 + 32)), + *(cast(double*)(arg0 + 40)), + ); + wit.pumpkin.plugin.event.imports.PlayerSpawnLocationEventData _record4499 = { + player: _handle4497, + spawnPos: _tuple4498, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 48)))) != 0, + }; + auto _payload4787 = _record4499; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerSpawnLocationEvent(_payload4787); + break; + } + case _Tag4520.playerUnregisterChannelEvent: { + auto _handle4501 = wit.pumpkin.plugin.event.imports.Player(*(cast(uint*)(arg0 + 16))); + auto _len4502 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + auto _ptr4502 = _len4502 ? cast(char*)(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))) : null; + if (_len4502) deallocate ~= cast()_ptr4502; + auto _list4503 = WitString(_ptr4502[0.._len4502]); + wit.pumpkin.plugin.event.imports.PlayerUnregisterChannelEventData _record4504 = { + player: _handle4501, + channel: _list4503, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+3*size_t.sizeof))))) != 0, + }; + auto _payload4788 = _record4504; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.playerUnregisterChannelEvent(_payload4788); + break; + } + case _Tag4520.raidFinishEvent: { + wit.pumpkin.plugin.event.common.RaidFinishEventData _record4506 = { + victory: (cast(uint)(*(cast(ubyte*)(arg0 + 16)))) != 0, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 17)))) != 0, + }; + auto _payload4789 = _record4506; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.raidFinishEvent(_payload4789); + break; + } + case _Tag4520.raidSpawnWaveEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4508 = { + x: cast(int)(*(cast(uint*)(arg0 + 20))), + y: cast(int)(*(cast(uint*)(arg0 + 24))), + z: cast(int)(*(cast(uint*)(arg0 + 28))), + }; + wit.pumpkin.plugin.event.common.RaidSpawnWaveEventData _record4509 = { + wave: *(cast(uint*)(arg0 + 16)), + pos: _record4508, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) != 0, + }; + auto _payload4790 = _record4509; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.raidSpawnWaveEvent(_payload4790); + break; + } + case _Tag4520.raidStopEvent: { + auto _len4511 = *(cast(size_t*)(arg0 + (16+1*size_t.sizeof))); + auto _ptr4511 = _len4511 ? cast(char*)(*(cast(void**)(arg0 + 16))) : null; + if (_len4511) deallocate ~= cast()_ptr4511; + auto _list4512 = WitString(_ptr4511[0.._len4511]); + wit.pumpkin.plugin.event.common.RaidStopEventData _record4513 = { + reason: _list4512, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + (16+2*size_t.sizeof))))) != 0, + }; + auto _payload4791 = _record4513; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.raidStopEvent(_payload4791); + break; + } + case _Tag4520.raidTriggerEvent: { + wit.pumpkin.plugin.common.common.BlockPos _record4515 = { + x: cast(int)(*(cast(uint*)(arg0 + 16))), + y: cast(int)(*(cast(uint*)(arg0 + 20))), + z: cast(int)(*(cast(uint*)(arg0 + 24))), + }; + wit.pumpkin.plugin.event.common.RaidTriggerEventData _record4516 = { + pos: _record4515, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 28)))) != 0, + }; + auto _payload4792 = _record4516; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.raidTriggerEvent(_payload4792); + break; + } + case _Tag4520.lightningStrikeEvent: { + auto _tuple4518 = wit.pumpkin.plugin.common.common.Position( + *(cast(double*)(arg0 + 16)), + *(cast(double*)(arg0 + 24)), + *(cast(double*)(arg0 + 32)), + ); + wit.pumpkin.plugin.event.common.LightningStrikeEventData _record4519 = { + position: _tuple4518, + isEffect: (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) != 0, + cancelled: (cast(uint)(*(cast(ubyte*)(arg0 + 41)))) != 0, + }; + auto _payload4793 = _record4519; + _variant4520 = wit.pumpkin.plugin.event.imports.Event.lightningStrikeEvent(_payload4793); + break; + } + } + auto _ret = handleEvent_Impl(*(cast(uint*)(arg0 + 0)), _handle0, _variant4520); + deallocate.purge(); + free(arg0);alias _Tag7236 = wit.pumpkin.plugin.event.imports.Event.Tag; + final switch (_ret.tag) { + case _Tag7236.playerJoinEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerJoinEventData _payload4795 = _ret.getPlayerJoinEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(0); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4795.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(_payload4795.joinMessage.__handle); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload4795.cancelled)); + break; + } + case _Tag7236.playerLeaveEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerLeaveEventData _payload4797 = _ret.getPlayerLeaveEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(1); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4797.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(_payload4797.leaveMessage.__handle); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload4797.cancelled)); + break; + } + case _Tag7236.playerLoginEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerLoginEventData _payload4799 = _ret.getPlayerLoginEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(2); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4799.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(_payload4799.kickMessage.__handle); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload4799.cancelled)); + break; + } + case _Tag7236.playerChatEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerChatEventData _payload4801 = _ret.getPlayerChatEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(3); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4801.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload4801.message.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4801.message.ptr)); + *cast(size_t*)(_retArea.ptr + (8+4*size_t.sizeof)) = cast(size_t)(_payload4801.recipients.length); + *cast(void**)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4801.recipients.ptr)); + if (_payload4801.signature.isSome) { + ref _payload4805 = _payload4801.signature.unwrap(); + *cast(ubyte*)(_retArea.ptr + (8+5*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (8+7*size_t.sizeof)) = cast(size_t)(_payload4805.length); + *cast(void**)(_retArea.ptr + (8+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4805.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (8+5*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + (8+8*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4801.cancelled)); + break; + } + case _Tag7236.playerCommandSendEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerCommandSendEventData _payload4807 = _ret.getPlayerCommandSendEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(4); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4807.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload4807.command.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4807.command.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4807.cancelled)); + break; + } + case _Tag7236.playerPermissionCheckEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerPermissionCheckEventData _payload4809 = _ret.getPlayerPermissionCheckEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(5); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4809.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload4809.permission.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4809.permission.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4809.permissionResult)); + break; + } + case _Tag7236.playerMoveEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerMoveEventData _payload4811 = _ret.getPlayerMoveEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(6); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4811.player.__handle); + *cast(double*)(_retArea.ptr + 16) = cast(double)(_payload4811.fromPosition[0]); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload4811.fromPosition[1]); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload4811.fromPosition[2]); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload4811.toPosition[0]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload4811.toPosition[1]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload4811.toPosition[2]); + *cast(ubyte*)(_retArea.ptr + 64) = cast(ubyte)(cast(uint)(_payload4811.cancelled)); + break; + } + case _Tag7236.playerTeleportEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerTeleportEventData _payload4813 = _ret.getPlayerTeleportEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(7); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4813.player.__handle); + *cast(double*)(_retArea.ptr + 16) = cast(double)(_payload4813.fromPosition[0]); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload4813.fromPosition[1]); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload4813.fromPosition[2]); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload4813.toPosition[0]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload4813.toPosition[1]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload4813.toPosition[2]); + *cast(ubyte*)(_retArea.ptr + 64) = cast(ubyte)(cast(uint)(_payload4813.cancelled)); + break; + } + case _Tag7236.playerChangeWorldEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerChangeWorldEventData _payload4815 = _ret.getPlayerChangeWorldEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(8); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4815.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(_payload4815.previousWorld.__handle); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(_payload4815.newWorld.__handle); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload4815.position[0]); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload4815.position[1]); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload4815.position[2]); + *cast(float*)(_retArea.ptr + 48) = cast(float)(_payload4815.yaw); + *cast(float*)(_retArea.ptr + 52) = cast(float)(_payload4815.pitch); + *cast(ubyte*)(_retArea.ptr + 56) = cast(ubyte)(cast(uint)(_payload4815.cancelled)); + break; + } + case _Tag7236.playerRespawnEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerRespawnEventData _payload4817 = _ret.getPlayerRespawnEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(9); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4817.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(_payload4817.previousWorld.__handle); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(_payload4817.respawnedWorld.__handle); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload4817.position[0]); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload4817.position[1]); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload4817.position[2]); + *cast(float*)(_retArea.ptr + 48) = cast(float)(_payload4817.yaw); + *cast(float*)(_retArea.ptr + 52) = cast(float)(_payload4817.pitch); + *cast(ubyte*)(_retArea.ptr + 56) = cast(ubyte)(cast(uint)(_payload4817.alive)); + break; + } + case _Tag7236.playerExpChangeEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerExpChangeEventData _payload4819 = _ret.getPlayerExpChangeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(10); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4819.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload4819.amount)); + break; + } + case _Tag7236.playerItemHeldEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerItemHeldEventData _payload4821 = _ret.getPlayerItemHeldEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(11); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4821.player.__handle); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload4821.previousSlot)); + *cast(ubyte*)(_retArea.ptr + 13) = cast(ubyte)(cast(uint)(_payload4821.newSlot)); + *cast(ubyte*)(_retArea.ptr + 14) = cast(ubyte)(cast(uint)(_payload4821.cancelled)); + break; + } + case _Tag7236.playerChangedMainHandEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerChangedMainHandEventData _payload4823 = _ret.getPlayerChangedMainHandEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(12); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4823.player.__handle); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload4823.mainHand)); + break; + } + case _Tag7236.playerGamemodeChangeEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerGamemodeChangeEventData _payload4825 = _ret.getPlayerGamemodeChangeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(13); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4825.player.__handle); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload4825.previousGamemode)); + *cast(ubyte*)(_retArea.ptr + 13) = cast(ubyte)(cast(uint)(_payload4825.newGamemode)); + *cast(ubyte*)(_retArea.ptr + 14) = cast(ubyte)(cast(uint)(_payload4825.cancelled)); + break; + } + case _Tag7236.playerCustomPayloadEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerCustomPayloadEventData _payload4827 = _ret.getPlayerCustomPayloadEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(14); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4827.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload4827.channel.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4827.channel.ptr)); + *cast(size_t*)(_retArea.ptr + (8+4*size_t.sizeof)) = cast(size_t)(_payload4827.data.length); + *cast(void**)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4827.data.ptr)); + break; + } + case _Tag7236.playerFishEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerFishEventData _payload4829 = _ret.getPlayerFishEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(15); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4829.player.__handle); + if (_payload4829.caughtUuid.isSome) { + ref _payload4833 = _payload4829.caughtUuid.unwrap(); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(1); + *cast(ulong*)(_retArea.ptr + 24) = cast(ulong)(_payload4833.high); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(_payload4833.low); + } else { + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(0); + } + *cast(size_t*)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(size_t)(_payload4829.caughtType.length); + *cast(void**)(_retArea.ptr + 40) = cast(void*)(cast(void*)(_payload4829.caughtType.ptr)); + *cast(ulong*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(ulong)(_payload4829.hookUuid.high); + *cast(ulong*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(ulong)(_payload4829.hookUuid.low); + *cast(ubyte*)(_retArea.ptr + (56+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4829.state)); + *cast(ubyte*)(_retArea.ptr + (57+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4829.hand)); + *cast(uint*)(_retArea.ptr + (60+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload4829.expToDrop)); + *cast(ubyte*)(_retArea.ptr + (64+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4829.cancelled)); + break; + } + case _Tag7236.playerEggThrowEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerEggThrowEventData _payload4835 = _ret.getPlayerEggThrowEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(16); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4835.player.__handle); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(_payload4835.eggUuid.high); + *cast(ulong*)(_retArea.ptr + 24) = cast(ulong)(_payload4835.eggUuid.low); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload4835.hatching)); + *cast(ubyte*)(_retArea.ptr + 33) = cast(ubyte)(cast(uint)(_payload4835.numHatches)); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload4835.hatchingType.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4835.hatchingType.ptr)); + *cast(ubyte*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4835.cancelled)); + break; + } + case _Tag7236.playerInteractUnknownEntityEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerInteractUnknownEntityEventData _payload4837 = _ret.getPlayerInteractUnknownEntityEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(17); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4837.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload4837.entityId)); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload4837.action)); + *cast(ubyte*)(_retArea.ptr + 17) = cast(ubyte)(cast(uint)(_payload4837.cancelled)); + break; + } + case _Tag7236.playerInteractEntityEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerInteractEntityEventData _payload4839 = _ret.getPlayerInteractEntityEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(18); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4839.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload4839.entityId)); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload4839.action)); + *cast(ubyte*)(_retArea.ptr + 17) = cast(ubyte)(cast(uint)(_payload4839.sneaking)); + *cast(ubyte*)(_retArea.ptr + 18) = cast(ubyte)(cast(uint)(_payload4839.cancelled)); + break; + } + case _Tag7236.playerInteractEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerInteractEventData _payload4841 = _ret.getPlayerInteractEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(19); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4841.player.__handle); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload4841.action)); + if (_payload4841.clickedPos.isSome) { + ref _payload4845 = _payload4841.clickedPos.unwrap(); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload4845.x)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload4845.y)); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload4845.z)); + } else { + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(0); + } + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload4841.block.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload4841.block.ptr)); + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4841.cancelled)); + break; + } + case _Tag7236.playerToggleSneakEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerToggleSneakEventData _payload4847 = _ret.getPlayerToggleSneakEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(20); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4847.player.__handle); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload4847.isSneaking)); + *cast(ubyte*)(_retArea.ptr + 13) = cast(ubyte)(cast(uint)(_payload4847.cancelled)); + break; + } + case _Tag7236.playerToggleFlightEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerToggleFlightEventData _payload4849 = _ret.getPlayerToggleFlightEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(21); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4849.player.__handle); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload4849.isFlying)); + *cast(ubyte*)(_retArea.ptr + 13) = cast(ubyte)(cast(uint)(_payload4849.cancelled)); + break; + } + case _Tag7236.playerToggleSprintEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerToggleSprintEventData _payload4851 = _ret.getPlayerToggleSprintEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(22); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4851.player.__handle); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload4851.isSprinting)); + *cast(ubyte*)(_retArea.ptr + 13) = cast(ubyte)(cast(uint)(_payload4851.cancelled)); + break; + } + case _Tag7236.inventoryClickEvent: { + ref wit.pumpkin.plugin.event.imports.InventoryClickEventData _payload4853 = _ret.getInventoryClickEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(23); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4853.player.__handle); + if (_payload4853.windowType.isSome) { + ref _payload4857 = _payload4853.windowType.unwrap(); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(1); + *cast(ubyte*)(_retArea.ptr + 13) = cast(ubyte)(cast(uint)(_payload4857)); + } else { + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + 14) = cast(ubyte)(cast(uint)(_payload4853.clickType)); + *cast(ushort*)(_retArea.ptr + 16) = cast(ushort)(cast(uint)(_payload4853.slot)); + *cast(ushort*)(_retArea.ptr + 18) = cast(ushort)(cast(uint)(_payload4853.rawSlot)); + if (_payload4853.clickedItem.isSome) { + ref _payload4861 = _payload4853.clickedItem.unwrap(); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(_payload4861.__handle); + } else { + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(0); + } + if (_payload4853.cursor.isSome) { + ref _payload4865 = _payload4853.cursor.unwrap(); + *cast(ubyte*)(_retArea.ptr + 28) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(_payload4865.__handle); + } else { + *cast(ubyte*)(_retArea.ptr + 28) = cast(ubyte)(0); + } + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload4853.hotbarButton)); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(cast(uint)(_payload4853.cancelled)); + break; + } + case _Tag7236.inventoryCloseEvent: { + ref wit.pumpkin.plugin.event.imports.InventoryCloseEventData _payload4867 = _ret.getInventoryCloseEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(24); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4867.player.__handle); + if (_payload4867.windowType.isSome) { + ref _payload4871 = _payload4867.windowType.unwrap(); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(1); + *cast(ubyte*)(_retArea.ptr + 13) = cast(ubyte)(cast(uint)(_payload4871)); + } else { + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(0); + } + break; + } + case _Tag7236.blockRedstoneEvent: { + ref wit.pumpkin.plugin.event.imports.BlockRedstoneEventData _payload4873 = _ret.getBlockRedstoneEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(25); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4873.targetWorld.__handle); + *cast(ushort*)(_retArea.ptr + 12) = cast(ushort)(cast(uint)(_payload4873.stateId)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload4873.blockPos.x)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload4873.blockPos.y)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload4873.blockPos.z)); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload4873.oldCurrent)); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload4873.newCurrent)); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(cast(uint)(_payload4873.cancelled)); + break; + } + case _Tag7236.blockBreakEvent: { + ref wit.pumpkin.plugin.event.imports.BlockBreakEventData _payload4875 = _ret.getBlockBreakEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(26); + if (_payload4875.player.isSome) { + ref _payload4879 = _payload4875.player.unwrap(); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(_payload4879.__handle); + } else { + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(0); + } + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload4875.block.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload4875.block.ptr)); + *cast(uint*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload4875.blockPos.x)); + *cast(uint*)(_retArea.ptr + (20+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload4875.blockPos.y)); + *cast(uint*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload4875.blockPos.z)); + *cast(uint*)(_retArea.ptr + (28+2*size_t.sizeof)) = cast(uint)(_payload4875.exp); + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4875.shouldDrop)); + *cast(ubyte*)(_retArea.ptr + (33+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4875.cancelled)); + break; + } + case _Tag7236.blockBurnEvent: { + ref wit.pumpkin.plugin.event.common.BlockBurnEventData _payload4881 = _ret.getBlockBurnEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(27); + *cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(size_t)(_payload4881.ignitingBlock.length); + *cast(void**)(_retArea.ptr + 8) = cast(void*)(cast(void*)(_payload4881.ignitingBlock.ptr)); + *cast(size_t*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(size_t)(_payload4881.block.length); + *cast(void**)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4881.block.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4881.cancelled)); + break; + } + case _Tag7236.blockCanBuildEvent: { + ref wit.pumpkin.plugin.event.imports.BlockCanBuildEventData _payload4883 = _ret.getBlockCanBuildEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(28); + *cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(size_t)(_payload4883.blockToBuild.length); + *cast(void**)(_retArea.ptr + 8) = cast(void*)(cast(void*)(_payload4883.blockToBuild.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4883.buildable)); + *cast(uint*)(_retArea.ptr + (12+2*size_t.sizeof)) = cast(uint)(_payload4883.player.__handle); + *cast(size_t*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(size_t)(_payload4883.block.length); + *cast(void**)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4883.block.ptr)); + *cast(ubyte*)(_retArea.ptr + (16+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4883.cancelled)); + break; + } + case _Tag7236.blockGrowEvent: { + ref wit.pumpkin.plugin.event.imports.BlockGrowEventData _payload4885 = _ret.getBlockGrowEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(29); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4885.targetWorld.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload4885.oldBlock.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4885.oldBlock.ptr)); + *cast(ushort*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ushort)(cast(uint)(_payload4885.oldStateId)); + *cast(size_t*)(_retArea.ptr + (8+5*size_t.sizeof)) = cast(size_t)(_payload4885.newBlock.length); + *cast(void**)(_retArea.ptr + (8+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4885.newBlock.ptr)); + *cast(ushort*)(_retArea.ptr + (8+6*size_t.sizeof)) = cast(ushort)(cast(uint)(_payload4885.newStateId)); + *cast(uint*)(_retArea.ptr + (12+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload4885.blockPos.x)); + *cast(uint*)(_retArea.ptr + (16+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload4885.blockPos.y)); + *cast(uint*)(_retArea.ptr + (20+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload4885.blockPos.z)); + *cast(ubyte*)(_retArea.ptr + (24+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4885.cancelled)); + break; + } + case _Tag7236.blockPlaceEvent: { + ref wit.pumpkin.plugin.event.imports.BlockPlaceEventData _payload4887 = _ret.getBlockPlaceEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(30); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4887.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload4887.blockPlaced.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4887.blockPlaced.ptr)); + *cast(size_t*)(_retArea.ptr + (8+4*size_t.sizeof)) = cast(size_t)(_payload4887.blockPlacedAgainst.length); + *cast(void**)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4887.blockPlacedAgainst.ptr)); + *cast(uint*)(_retArea.ptr + (8+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload4887.blockPos.x)); + *cast(uint*)(_retArea.ptr + (12+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload4887.blockPos.y)); + *cast(uint*)(_retArea.ptr + (16+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload4887.blockPos.z)); + *cast(ubyte*)(_retArea.ptr + (20+5*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4887.canBuild)); + *cast(ubyte*)(_retArea.ptr + (21+5*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4887.cancelled)); + break; + } + case _Tag7236.dialogClickActionEvent: { + ref wit.pumpkin.plugin.event.imports.DialogClickActionEventData _payload4889 = _ret.getDialogClickActionEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(31); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4889.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload4889.id.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4889.id.ptr)); + if (_payload4889.payload.isSome) { + ref _payload4893 = _payload4889.payload.unwrap(); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (8+5*size_t.sizeof)) = cast(size_t)(_payload4893.length); + *cast(void**)(_retArea.ptr + (8+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4893.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + (8+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4889.cancelled)); + break; + } + case _Tag7236.dialogShowEvent: { + ref wit.pumpkin.plugin.event.imports.DialogShowEventData _payload4895 = _ret.getDialogShowEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(32); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4895.player.__handle); + *cast(uint*)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(uint)(_payload4895.dialog.title.__handle); + *cast(ubyte*)(_retArea.ptr + (12+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4895.dialog.type)); + auto _listSrc4902 = _payload4895.dialog.body_; + auto _list4902 = _listSrc4902.length ? wit.common.malloc(_listSrc4902.length * (8)) : null; + assert(!_listSrc4902.length || _list4902); + foreach (_elem4896_idx, ref _elem4896; _listSrc4902) { + auto _base4896 = _list4902 + _elem4896_idx * (8); + alias _Tag4901 = wit.pumpkin.plugin.java_dialogs.imports.DialogBody.Tag; + final switch (_elem4896.tag) { + case _Tag4901.plainMessage: { + ref wit.pumpkin.plugin.java_dialogs.imports.TextComponent _payload4898 = _elem4896.getPlainMessage(); + *cast(ubyte*)(_base4896 + 0) = cast(ubyte)(0); + *cast(uint*)(_base4896 + 4) = cast(uint)(_payload4898.__handle); + break; + } + case _Tag4901.item: { + ref wit.pumpkin.plugin.java_dialogs.imports.ItemStack _payload4900 = _elem4896.getItem(); + *cast(ubyte*)(_base4896 + 0) = cast(ubyte)(1); + *cast(uint*)(_base4896 + 4) = cast(uint)(_payload4900.__handle); + break; + } + } + + } + if (_listSrc4902.length) wit.common.free(_listSrc4902.ptr); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload4895.dialog.body_.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(_list4902); + auto _listSrc4917 = _payload4895.dialog.inputs; + auto _list4917 = _listSrc4917.length ? wit.common.malloc(_listSrc4917.length * ((16+5*size_t.sizeof))) : null; + assert(!_listSrc4917.length || _list4917); + foreach (_elem4903_idx, ref _elem4903; _listSrc4917) { + auto _base4903 = _list4917 + _elem4903_idx * ((16+5*size_t.sizeof)); + alias _Tag4916 = wit.pumpkin.plugin.java_dialogs.imports.DialogInput.Tag; + final switch (_elem4903.tag) { + case _Tag4916.bool_: { + ref wit.pumpkin.plugin.java_dialogs.imports.DialogInputBool _payload4905 = _elem4903.getBool(); + *cast(ubyte*)(_base4903 + 0) = cast(ubyte)(0); + *cast(uint*)(_base4903 + size_t.sizeof) = cast(uint)(_payload4905.label.__handle); + *cast(ubyte*)(_base4903 + (4+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4905.defaultValue)); + break; + } + case _Tag4916.text: { + ref wit.pumpkin.plugin.java_dialogs.imports.DialogInputText _payload4907 = _elem4903.getText(); + *cast(ubyte*)(_base4903 + 0) = cast(ubyte)(1); + *cast(uint*)(_base4903 + size_t.sizeof) = cast(uint)(_payload4907.label.__handle); + *cast(uint*)(_base4903 + (4+1*size_t.sizeof)) = cast(uint)(_payload4907.placeholder.__handle); + *cast(size_t*)(_base4903 + (8+2*size_t.sizeof)) = cast(size_t)(_payload4907.defaultValue.length); + *cast(void**)(_base4903 + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4907.defaultValue.ptr)); + break; + } + case _Tag4916.numberRange: { + ref wit.pumpkin.plugin.java_dialogs.imports.DialogInputNumberRange _payload4909 = _elem4903.getNumberRange(); + *cast(ubyte*)(_base4903 + 0) = cast(ubyte)(2); + *cast(uint*)(_base4903 + size_t.sizeof) = cast(uint)(_payload4909.label.__handle); + *cast(float*)(_base4903 + (4+1*size_t.sizeof)) = cast(float)(_payload4909.minValue); + *cast(float*)(_base4903 + (8+1*size_t.sizeof)) = cast(float)(_payload4909.maxValue); + *cast(float*)(_base4903 + (12+1*size_t.sizeof)) = cast(float)(_payload4909.initialValue); + *cast(float*)(_base4903 + (16+1*size_t.sizeof)) = cast(float)(_payload4909.step); + if (_payload4909.labelFormat.isSome) { + ref _payload4913 = _payload4909.labelFormat.unwrap(); + *cast(ubyte*)(_base4903 + (16+2*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_base4903 + (16+4*size_t.sizeof)) = cast(size_t)(_payload4913.length); + *cast(void**)(_base4903 + (16+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4913.ptr)); + } else { + *cast(ubyte*)(_base4903 + (16+2*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag4916.singleOption: { + ref wit.pumpkin.plugin.java_dialogs.imports.DialogInputSingleOption _payload4915 = _elem4903.getSingleOption(); + *cast(ubyte*)(_base4903 + 0) = cast(ubyte)(3); + *cast(uint*)(_base4903 + size_t.sizeof) = cast(uint)(_payload4915.label.__handle); + *cast(size_t*)(_base4903 + (3*size_t.sizeof)) = cast(size_t)(_payload4915.options.length); + *cast(void**)(_base4903 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4915.options.ptr)); + *cast(uint*)(_base4903 + (4*size_t.sizeof)) = cast(uint)(_payload4915.initialIndex); + break; + } + } + + } + if (_listSrc4917.length) wit.common.free(_listSrc4917.ptr); + *cast(size_t*)(_retArea.ptr + (16+4*size_t.sizeof)) = cast(size_t)(_payload4895.dialog.inputs.length); + *cast(void**)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(void*)(_list4917); + auto _listSrc4936 = _payload4895.dialog.buttons; + auto _list4936 = _listSrc4936.length ? wit.common.malloc(_listSrc4936.length * ((16+7*size_t.sizeof))) : null; + assert(!_listSrc4936.length || _list4936); + foreach (_elem4918_idx, ref _elem4918; _listSrc4936) { + auto _base4918 = _list4936 + _elem4918_idx * ((16+7*size_t.sizeof)); + *cast(uint*)(_base4918 + 0) = cast(uint)(_elem4918.text.__handle); + if (_elem4918.tooltip.isSome) { + ref _payload4922 = _elem4918.tooltip.unwrap(); + *cast(ubyte*)(_base4918 + 4) = cast(ubyte)(1); + *cast(uint*)(_base4918 + 8) = cast(uint)(_payload4922.__handle); + } else { + *cast(ubyte*)(_base4918 + 4) = cast(ubyte)(0); + } + if (_elem4918.width.isSome) { + ref _payload4926 = _elem4918.width.unwrap(); + *cast(ubyte*)(_base4918 + 12) = cast(ubyte)(1); + *cast(uint*)(_base4918 + 16) = cast(uint)(_payload4926); + } else { + *cast(ubyte*)(_base4918 + 12) = cast(ubyte)(0); + } + alias _Tag4935 = wit.pumpkin.plugin.java_dialogs.common.Action.Tag; + final switch (_elem4918.action.tag) { + case _Tag4935.openUrl: { + ref WitString _payload4928 = _elem4918.action.getOpenUrl(); + *cast(ubyte*)(_base4918 + (16+1*size_t.sizeof)) = cast(ubyte)(0); + *cast(size_t*)(_base4918 + (16+3*size_t.sizeof)) = cast(size_t)(_payload4928.length); + *cast(void**)(_base4918 + (16+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4928.ptr)); + break; + } + case _Tag4935.customClick: { + ref wit.pumpkin.plugin.java_dialogs.common.CustomClickAction _payload4930 = _elem4918.action.getCustomClick(); + *cast(ubyte*)(_base4918 + (16+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_base4918 + (16+3*size_t.sizeof)) = cast(size_t)(_payload4930.id.length); + *cast(void**)(_base4918 + (16+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4930.id.ptr)); + if (_payload4930.payload.isSome) { + ref _payload4934 = _payload4930.payload.unwrap(); + *cast(ubyte*)(_base4918 + (16+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_base4918 + (16+6*size_t.sizeof)) = cast(size_t)(_payload4934.length); + *cast(void**)(_base4918 + (16+5*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4934.ptr)); + } else { + *cast(ubyte*)(_base4918 + (16+4*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + } + + } + if (_listSrc4936.length) wit.common.free(_listSrc4936.ptr); + *cast(size_t*)(_retArea.ptr + (16+6*size_t.sizeof)) = cast(size_t)(_payload4895.dialog.buttons.length); + *cast(void**)(_retArea.ptr + (16+5*size_t.sizeof)) = cast(void*)(_list4936); + auto _listSrc4943 = _payload4895.dialog.links; + auto _list4943 = _listSrc4943.length ? wit.common.malloc(_listSrc4943.length * ((8+2*size_t.sizeof))) : null; + assert(!_listSrc4943.length || _list4943); + foreach (_elem4937_idx, ref _elem4937; _listSrc4943) { + auto _base4937 = _list4943 + _elem4937_idx * ((8+2*size_t.sizeof)); + alias _Tag4942 = wit.pumpkin.plugin.java_dialogs.imports.LinkLabel.Tag; + final switch (_elem4937.label.tag) { + case _Tag4942.builtIn: { + ref wit.pumpkin.plugin.java_dialogs.common.LinkType _payload4939 = _elem4937.label.getBuiltIn(); + *cast(ubyte*)(_base4937 + 0) = cast(ubyte)(0); + *cast(ubyte*)(_base4937 + 4) = cast(ubyte)(cast(uint)(_payload4939)); + break; + } + case _Tag4942.custom: { + ref wit.pumpkin.plugin.java_dialogs.imports.TextComponent _payload4941 = _elem4937.label.getCustom(); + *cast(ubyte*)(_base4937 + 0) = cast(ubyte)(1); + *cast(uint*)(_base4937 + 4) = cast(uint)(_payload4941.__handle); + break; + } + } + *cast(size_t*)(_base4937 + (8+1*size_t.sizeof)) = cast(size_t)(_elem4937.url.length); + *cast(void**)(_base4937 + 8) = cast(void*)(cast(void*)(_elem4937.url.ptr)); + + } + if (_listSrc4943.length) wit.common.free(_listSrc4943.ptr); + *cast(size_t*)(_retArea.ptr + (16+8*size_t.sizeof)) = cast(size_t)(_payload4895.dialog.links.length); + *cast(void**)(_retArea.ptr + (16+7*size_t.sizeof)) = cast(void*)(_list4943); + if (_payload4895.dialog.afterAction.isSome) { + ref _payload4947 = _payload4895.dialog.afterAction.unwrap(); + *cast(ubyte*)(_retArea.ptr + (16+9*size_t.sizeof)) = cast(ubyte)(1); + *cast(ubyte*)(_retArea.ptr + (17+9*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4947)); + } else { + *cast(ubyte*)(_retArea.ptr + (16+9*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + (18+9*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4895.dialog.canCloseWithEscape)); + if (_payload4895.dialog.externalTitle.isSome) { + ref _payload4951 = _payload4895.dialog.externalTitle.unwrap(); + *cast(ubyte*)(_retArea.ptr + (20+9*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (24+9*size_t.sizeof)) = cast(uint)(_payload4951.__handle); + } else { + *cast(ubyte*)(_retArea.ptr + (20+9*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + (24+10*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4895.cancelled)); + break; + } + case _Tag7236.dialogClearEvent: { + ref wit.pumpkin.plugin.event.imports.DialogClearEventData _payload4953 = _ret.getDialogClearEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(33); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4953.player.__handle); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload4953.cancelled)); + break; + } + case _Tag7236.bedrockFormResponseEvent: { + ref wit.pumpkin.plugin.event.imports.BedrockFormResponseEventData _payload4955 = _ret.getBedrockFormResponseEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(34); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4955.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(_payload4955.formId); + if (_payload4955.responseData.isSome) { + ref _payload4959 = _payload4955.responseData.unwrap(); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload4959.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4959.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(0); + } + break; + } + case _Tag7236.serverCommandEvent: { + ref wit.pumpkin.plugin.event.common.ServerCommandEventData _payload4961 = _ret.getServerCommandEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(35); + *cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(size_t)(_payload4961.command.length); + *cast(void**)(_retArea.ptr + 8) = cast(void*)(cast(void*)(_payload4961.command.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4961.cancelled)); + break; + } + case _Tag7236.serverListPingEvent: { + ref wit.pumpkin.plugin.event.imports.ServerListPingEventData _payload4963 = _ret.getServerListPingEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(36); + *cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(size_t)(_payload4963.hostname.length); + *cast(void**)(_retArea.ptr + 8) = cast(void*)(cast(void*)(_payload4963.hostname.ptr)); + *cast(size_t*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(size_t)(_payload4963.address.host.length); + *cast(void**)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4963.address.host.ptr)); + *cast(ushort*)(_retArea.ptr + (8+4*size_t.sizeof)) = cast(ushort)(cast(uint)(_payload4963.address.port)); + *cast(uint*)(_retArea.ptr + (8+5*size_t.sizeof)) = cast(uint)(_payload4963.motd.__handle); + *cast(uint*)(_retArea.ptr + (12+5*size_t.sizeof)) = cast(uint)(_payload4963.maxPlayers); + *cast(uint*)(_retArea.ptr + (16+5*size_t.sizeof)) = cast(uint)(_payload4963.numPlayers); + if (_payload4963.favicon.isSome) { + ref _payload4967 = _payload4963.favicon.unwrap(); + *cast(ubyte*)(_retArea.ptr + (16+6*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (16+8*size_t.sizeof)) = cast(size_t)(_payload4967.length); + *cast(void**)(_retArea.ptr + (16+7*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4967.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (16+6*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag7236.serverLoadEvent: { + ref wit.pumpkin.plugin.event.common.ServerLoadEventData _payload4969 = _ret.getServerLoadEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(37); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(cast(uint)(_payload4969.loadType)); + break; + } + case _Tag7236.spawnChangeEvent: { + ref wit.pumpkin.plugin.event.imports.SpawnChangeEventData _payload4971 = _ret.getSpawnChangeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(38); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4971.targetWorld.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload4971.previousPosition.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload4971.previousPosition.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload4971.previousPosition.z)); + *cast(float*)(_retArea.ptr + 24) = cast(float)(_payload4971.previousYaw); + *cast(float*)(_retArea.ptr + 28) = cast(float)(_payload4971.previousPitch); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload4971.newPosition.x)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload4971.newPosition.y)); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload4971.newPosition.z)); + *cast(float*)(_retArea.ptr + 44) = cast(float)(_payload4971.newYaw); + *cast(float*)(_retArea.ptr + 48) = cast(float)(_payload4971.newPitch); + break; + } + case _Tag7236.serverBroadcastEvent: { + ref wit.pumpkin.plugin.event.imports.ServerBroadcastEventData _payload4973 = _ret.getServerBroadcastEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(39); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4973.message.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(_payload4973.sender.__handle); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload4973.cancelled)); + break; + } + case _Tag7236.serverTickStartEvent: { + ref wit.pumpkin.plugin.event.common.ServerTickStartEventData _payload4975 = _ret.getServerTickStartEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(40); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload4975.tick)); + break; + } + case _Tag7236.serverTickEndEvent: { + ref wit.pumpkin.plugin.event.common.ServerTickEndEventData _payload4977 = _ret.getServerTickEndEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(41); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload4977.tick)); + *cast(ulong*)(_retArea.ptr + 16) = cast(ulong)(cast(ulong)(_payload4977.durationNanos)); + break; + } + case _Tag7236.packetReceivedEvent: { + ref wit.pumpkin.plugin.event.imports.PacketReceivedEventData _payload4979 = _ret.getPacketReceivedEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(42); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload4979.player.__handle); + alias _Tag5593 = wit.pumpkin.plugin.event.common.ServerboundPacket.Tag; + final switch (_payload4979.packet.tag) { + case _Tag5593.java: { + ref wit.pumpkin.plugin.event.common.JavaServerboundPacket _payload4981 = _payload4979.packet.getJava(); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(0); + alias _Tag5233 = wit.pumpkin.plugin.java_packets.common.ServerboundPacket.Tag; + final switch (_payload4981.tag) { + case _Tag5233.configSAcceptCodeOfConduct: { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(0); + break; + } + case _Tag5233.configSAcknowledgeFinishConfig: { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(1); + break; + } + case _Tag5233.configSClientInformationConfig: { + ref wit.pumpkin.plugin.java_packets.common.ConfigSClientInformationConfig _payload4987 = _payload4981.getConfigSClientInformationConfig(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(2); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload4987.locale.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload4987.locale.ptr)); + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4987.viewDistance)); + *cast(uint*)(_retArea.ptr + (36+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload4987.chatMode)); + *cast(ubyte*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4987.chatColors)); + *cast(ubyte*)(_retArea.ptr + (41+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4987.skinParts)); + *cast(uint*)(_retArea.ptr + (44+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload4987.mainHand)); + *cast(ubyte*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4987.textFiltering)); + *cast(ubyte*)(_retArea.ptr + (49+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4987.serverListing)); + break; + } + case _Tag5233.configSConfigCookieResponse: { + ref wit.pumpkin.plugin.java_packets.common.ConfigSConfigCookieResponse _payload4989 = _payload4981.getConfigSConfigCookieResponse(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(3); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload4989.key.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload4989.key.ptr)); + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4989.hasPayload)); + if (_payload4989.payload.isSome) { + ref _payload4993 = _payload4989.payload.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+5*size_t.sizeof)) = cast(size_t)(_payload4993.length); + *cast(void**)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4993.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag5233.configSCustomClickAction: { + ref wit.pumpkin.plugin.java_packets.common.ConfigSCustomClickAction _payload4995 = _payload4981.getConfigSCustomClickAction(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(4); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload4995.actionId.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload4995.actionId.ptr)); + if (_payload4995.payload.isSome) { + ref _payload4999 = _payload4995.payload.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(size_t)(_payload4999.length); + *cast(void**)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4999.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag5233.configSKeepAlive: { + ref wit.pumpkin.plugin.java_packets.common.ConfigSKeepAlive _payload5001 = _payload4981.getConfigSKeepAlive(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(5); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload5001.keepAliveId)); + break; + } + case _Tag5233.configSKnownPacks: { + ref wit.pumpkin.plugin.java_packets.common.ConfigSKnownPacks _payload5003 = _payload4981.getConfigSKnownPacks(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(6); + auto _listSrc5005 = _payload5003.knownPacks; + auto _list5005 = _listSrc5005.length ? wit.common.malloc(_listSrc5005.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5005.length || _list5005); + foreach (_elem5004_idx, ref _elem5004; _listSrc5005) { + auto _base5004 = _list5005 + _elem5004_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5004 + size_t.sizeof) = cast(size_t)(_elem5004.length); + *cast(void**)(_base5004 + 0) = cast(void*)(cast(void*)(_elem5004.ptr)); + + } + if (_listSrc5005.length) wit.common.free(_listSrc5005.ptr); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5003.knownPacks.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(_list5005); + break; + } + case _Tag5233.configSPluginMessage: { + ref wit.pumpkin.plugin.java_packets.common.ConfigSPluginMessage _payload5007 = _payload4981.getConfigSPluginMessage(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(7); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5007.channel.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5007.channel.ptr)); + *cast(size_t*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(size_t)(_payload5007.data.length); + *cast(void**)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5007.data.ptr)); + break; + } + case _Tag5233.configSConfigPong: { + ref wit.pumpkin.plugin.java_packets.common.ConfigSConfigPong _payload5009 = _payload4981.getConfigSConfigPong(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(8); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5009.id)); + break; + } + case _Tag5233.configSConfigResourcePack: { + ref wit.pumpkin.plugin.java_packets.common.ConfigSConfigResourcePack _payload5011 = _payload4981.getConfigSConfigResourcePack(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(9); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(_payload5011.uuid.high); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(_payload5011.uuid.low); + *cast(uint*)(_retArea.ptr + 48) = cast(uint)(cast(uint)(_payload5011.result)); + break; + } + case _Tag5233.loginSLoginCookieResponse: { + ref wit.pumpkin.plugin.java_packets.common.LoginSLoginCookieResponse _payload5013 = _payload4981.getLoginSLoginCookieResponse(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(10); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5013.key.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5013.key.ptr)); + if (_payload5013.payload.isSome) { + ref _payload5017 = _payload5013.payload.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(size_t)(_payload5017.length); + *cast(void**)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5017.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag5233.loginSLoginAcknowledged: { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(11); + break; + } + case _Tag5233.loginSLoginStart: { + ref wit.pumpkin.plugin.java_packets.common.LoginSLoginStart _payload5021 = _payload4981.getLoginSLoginStart(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(12); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5021.name.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5021.name.ptr)); + *cast(ulong*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ulong)(_payload5021.uuid.high); + *cast(ulong*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(ulong)(_payload5021.uuid.low); + break; + } + case _Tag5233.loginSLoginPluginResponse: { + ref wit.pumpkin.plugin.java_packets.common.LoginSLoginPluginResponse _payload5023 = _payload4981.getLoginSLoginPluginResponse(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(13); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5023.messageId)); + if (_payload5023.data.isSome) { + ref _payload5027 = _payload5023.data.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(size_t)(_payload5027.length); + *cast(void**)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5027.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag5233.sAttack: { + ref wit.pumpkin.plugin.java_packets.common.SAttack _payload5029 = _payload4981.getSAttack(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(14); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5029.entityId)); + break; + } + case _Tag5233.sBlockEntityTagQuery: { + ref wit.pumpkin.plugin.java_packets.common.SBlockEntityTagQuery _payload5031 = _payload4981.getSBlockEntityTagQuery(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(15); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5031.transactionId)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5031.location[0])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5031.location[1])); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload5031.location[2])); + break; + } + case _Tag5233.sBundleItemSelected: { + ref wit.pumpkin.plugin.java_packets.common.SBundleItemSelected _payload5033 = _payload4981.getSBundleItemSelected(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(16); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5033.slotId)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5033.selectedItemIndex)); + break; + } + case _Tag5233.sChangeDifficulty: { + ref wit.pumpkin.plugin.java_packets.common.SChangeDifficulty _payload5035 = _payload4981.getSChangeDifficulty(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(17); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5035.difficulty.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5035.difficulty.ptr)); + break; + } + case _Tag5233.sChangeGameMode: { + ref wit.pumpkin.plugin.java_packets.common.SChangeGameMode _payload5037 = _payload4981.getSChangeGameMode(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(18); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5037.gameMode.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5037.gameMode.ptr)); + break; + } + case _Tag5233.sChatAck: { + ref wit.pumpkin.plugin.java_packets.common.SChatAck _payload5039 = _payload4981.getSChatAck(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(19); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5039.offset)); + break; + } + case _Tag5233.sChatCommand: { + ref wit.pumpkin.plugin.java_packets.common.SChatCommand _payload5041 = _payload4981.getSChatCommand(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(20); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5041.command.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5041.command.ptr)); + break; + } + case _Tag5233.sChatCommandSigned: { + ref wit.pumpkin.plugin.java_packets.common.SChatCommandSigned _payload5043 = _payload4981.getSChatCommandSigned(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(21); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5043.command.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5043.command.ptr)); + *cast(ulong*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload5043.timestamp)); + *cast(ulong*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload5043.salt)); + auto _listSrc5045 = _payload5043.argumentSignatures; + auto _list5045 = _listSrc5045.length ? wit.common.malloc(_listSrc5045.length * ((4*size_t.sizeof))) : null; + assert(!_listSrc5045.length || _list5045); + foreach (_elem5044_idx, ref _elem5044; _listSrc5045) { + auto _base5044 = _list5045 + _elem5044_idx * ((4*size_t.sizeof)); + *cast(size_t*)(_base5044 + size_t.sizeof) = cast(size_t)(_elem5044.name.length); + *cast(void**)(_base5044 + 0) = cast(void*)(cast(void*)(_elem5044.name.ptr)); + *cast(size_t*)(_base5044 + (3*size_t.sizeof)) = cast(size_t)(_elem5044.signature.length); + *cast(void**)(_base5044 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem5044.signature.ptr)); + + } + if (_listSrc5045.length) wit.common.free(_listSrc5045.ptr); + *cast(size_t*)(_retArea.ptr + (48+3*size_t.sizeof)) = cast(size_t)(_payload5043.argumentSignatures.length); + *cast(void**)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(void*)(_list5045); + *cast(uint*)(_retArea.ptr + (48+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5043.messageCount)); + *cast(size_t*)(_retArea.ptr + (48+6*size_t.sizeof)) = cast(size_t)(_payload5043.acknowledged.length); + *cast(void**)(_retArea.ptr + (48+5*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5043.acknowledged.ptr)); + *cast(ubyte*)(_retArea.ptr + (48+7*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5043.checksum)); + break; + } + case _Tag5233.sChatMessage: { + ref wit.pumpkin.plugin.java_packets.common.SChatMessage _payload5047 = _payload4981.getSChatMessage(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(22); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5047.message.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5047.message.ptr)); + *cast(ulong*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload5047.timestamp)); + *cast(ulong*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload5047.salt)); + if (_payload5047.signature.isSome) { + ref _payload5051 = _payload5047.signature.unwrap(); + *cast(ubyte*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (48+4*size_t.sizeof)) = cast(size_t)(_payload5051.length); + *cast(void**)(_retArea.ptr + (48+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5051.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(uint*)(_retArea.ptr + (48+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5047.messageCount)); + *cast(size_t*)(_retArea.ptr + (48+7*size_t.sizeof)) = cast(size_t)(_payload5047.acknowledged.length); + *cast(void**)(_retArea.ptr + (48+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5047.acknowledged.ptr)); + *cast(ubyte*)(_retArea.ptr + (48+8*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5047.checksum)); + break; + } + case _Tag5233.sChunkBatch: { + ref wit.pumpkin.plugin.java_packets.common.SChunkBatch _payload5053 = _payload4981.getSChunkBatch(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(23); + *cast(float*)(_retArea.ptr + 32) = cast(float)(_payload5053.chunksPerTick); + break; + } + case _Tag5233.sClickSlot: { + ref wit.pumpkin.plugin.java_packets.common.SClickSlot _payload5055 = _payload4981.getSClickSlot(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(24); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5055.syncId)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5055.revision)); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5055.slot)); + *cast(ubyte*)(_retArea.ptr + 44) = cast(ubyte)(cast(uint)(_payload5055.button)); + *cast(ubyte*)(_retArea.ptr + 45) = cast(ubyte)(cast(uint)(_payload5055.mode)); + *cast(uint*)(_retArea.ptr + 48) = cast(uint)(cast(uint)(_payload5055.lengthOfArray)); + auto _listSrc5057 = _payload5055.arrayOfChangedSlots; + auto _list5057 = _listSrc5057.length ? wit.common.malloc(_listSrc5057.length * ((3*size_t.sizeof))) : null; + assert(!_listSrc5057.length || _list5057); + foreach (_elem5056_idx, ref _elem5056; _listSrc5057) { + auto _base5056 = _list5057 + _elem5056_idx * ((3*size_t.sizeof)); + *cast(uint*)(_base5056 + 0) = cast(uint)(cast(uint)(_elem5056[0])); + *cast(size_t*)(_base5056 + (2*size_t.sizeof)) = cast(size_t)(_elem5056[1].length); + *cast(void**)(_base5056 + size_t.sizeof) = cast(void*)(cast(void*)(_elem5056[1].ptr)); + + } + if (_listSrc5057.length) wit.common.free(_listSrc5057.ptr); + *cast(size_t*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(size_t)(_payload5055.arrayOfChangedSlots.length); + *cast(void**)(_retArea.ptr + (48+1*size_t.sizeof)) = cast(void*)(_list5057); + *cast(size_t*)(_retArea.ptr + (48+4*size_t.sizeof)) = cast(size_t)(_payload5055.carriedItem.length); + *cast(void**)(_retArea.ptr + (48+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5055.carriedItem.ptr)); + break; + } + case _Tag5233.sClientCommand: { + ref wit.pumpkin.plugin.java_packets.common.SClientCommand _payload5059 = _payload4981.getSClientCommand(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(25); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5059.actionId)); + break; + } + case _Tag5233.sClientInformationPlay: { + ref wit.pumpkin.plugin.java_packets.common.SClientInformationPlay _payload5061 = _payload4981.getSClientInformationPlay(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(26); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5061.locale.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5061.locale.ptr)); + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5061.viewDistance)); + *cast(uint*)(_retArea.ptr + (36+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5061.chatMode)); + *cast(ubyte*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5061.chatColors)); + *cast(ubyte*)(_retArea.ptr + (41+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5061.skinParts)); + *cast(uint*)(_retArea.ptr + (44+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5061.mainHand)); + *cast(ubyte*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5061.textFiltering)); + *cast(ubyte*)(_retArea.ptr + (49+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5061.serverListing)); + break; + } + case _Tag5233.sClientTickEnd: { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(27); + break; + } + case _Tag5233.sCloseContainer: { + ref wit.pumpkin.plugin.java_packets.common.SCloseContainer _payload5065 = _payload4981.getSCloseContainer(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(28); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5065.windowId)); + break; + } + case _Tag5233.sCommandSuggestion: { + ref wit.pumpkin.plugin.java_packets.common.SCommandSuggestion _payload5067 = _payload4981.getSCommandSuggestion(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(29); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5067.id)); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload5067.command.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5067.command.ptr)); + break; + } + case _Tag5233.sConfigurationAcknowledged: { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(30); + break; + } + case _Tag5233.sContainerButtonClick: { + ref wit.pumpkin.plugin.java_packets.common.SContainerButtonClick _payload5071 = _payload4981.getSContainerButtonClick(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(31); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5071.windowId)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5071.buttonId)); + break; + } + case _Tag5233.sContainerSlotStateChanged: { + ref wit.pumpkin.plugin.java_packets.common.SContainerSlotStateChanged _payload5073 = _payload4981.getSContainerSlotStateChanged(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(32); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5073.slotId)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5073.containerId)); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(cast(uint)(_payload5073.newState)); + break; + } + case _Tag5233.sCookieResponse: { + ref wit.pumpkin.plugin.java_packets.common.SCookieResponse _payload5075 = _payload4981.getSCookieResponse(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(33); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5075.key.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5075.key.ptr)); + if (_payload5075.payload.isSome) { + ref _payload5079 = _payload5075.payload.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(size_t)(_payload5079.length); + *cast(void**)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5079.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag5233.sCustomClickAction: { + ref wit.pumpkin.plugin.java_packets.common.SCustomClickAction _payload5081 = _payload4981.getSCustomClickAction(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(34); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5081.actionId.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5081.actionId.ptr)); + if (_payload5081.payload.isSome) { + ref _payload5085 = _payload5081.payload.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(size_t)(_payload5085.length); + *cast(void**)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5085.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag5233.sCustomPayload: { + ref wit.pumpkin.plugin.java_packets.common.SCustomPayload _payload5087 = _payload4981.getSCustomPayload(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(35); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5087.channel.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5087.channel.ptr)); + *cast(size_t*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(size_t)(_payload5087.data.length); + *cast(void**)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5087.data.ptr)); + break; + } + case _Tag5233.sDebugSampleSubscription: { + ref wit.pumpkin.plugin.java_packets.common.SDebugSampleSubscription _payload5089 = _payload4981.getSDebugSampleSubscription(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(36); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5089.sampleType)); + break; + } + case _Tag5233.sDebugSubscriptionRequest: { + ref wit.pumpkin.plugin.java_packets.common.SDebugSubscriptionRequest _payload5091 = _payload4981.getSDebugSubscriptionRequest(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(37); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5091.sampleType)); + break; + } + case _Tag5233.sEditBook: { + ref wit.pumpkin.plugin.java_packets.common.SEditBook _payload5093 = _payload4981.getSEditBook(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(38); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5093.slot)); + auto _listSrc5095 = _payload5093.pages; + auto _list5095 = _listSrc5095.length ? wit.common.malloc(_listSrc5095.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5095.length || _list5095); + foreach (_elem5094_idx, ref _elem5094; _listSrc5095) { + auto _base5094 = _list5095 + _elem5094_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5094 + size_t.sizeof) = cast(size_t)(_elem5094.length); + *cast(void**)(_base5094 + 0) = cast(void*)(cast(void*)(_elem5094.ptr)); + + } + if (_listSrc5095.length) wit.common.free(_listSrc5095.ptr); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload5093.pages.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(_list5095); + if (_payload5093.title.isSome) { + ref _payload5099 = _payload5093.title.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+5*size_t.sizeof)) = cast(size_t)(_payload5099.length); + *cast(void**)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5099.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag5233.sEntityTagQuery: { + ref wit.pumpkin.plugin.java_packets.common.SEntityTagQuery _payload5101 = _payload4981.getSEntityTagQuery(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(39); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5101.transactionId)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5101.entityId)); + break; + } + case _Tag5233.sInteract: { + ref wit.pumpkin.plugin.java_packets.common.SInteract _payload5103 = _payload4981.getSInteract(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(40); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5103.entityId)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5103.rType)); + if (_payload5103.targetPosition.isSome) { + ref _payload5107 = _payload5103.targetPosition.unwrap(); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(1); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload5107[0]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload5107[1]); + *cast(double*)(_retArea.ptr + 64) = cast(double)(_payload5107[2]); + } else { + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(0); + } + if (_payload5103.hand.isSome) { + ref _payload5111 = _payload5103.hand.unwrap(); + *cast(ubyte*)(_retArea.ptr + 72) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 76) = cast(uint)(cast(uint)(_payload5111)); + } else { + *cast(ubyte*)(_retArea.ptr + 72) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + 80) = cast(ubyte)(cast(uint)(_payload5103.sneaking)); + break; + } + case _Tag5233.sJigsawGenerate: { + ref wit.pumpkin.plugin.java_packets.common.SJigsawGenerate _payload5113 = _payload4981.getSJigsawGenerate(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(41); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5113.pos[0])); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5113.pos[1])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5113.pos[2])); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload5113.levels)); + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(cast(uint)(_payload5113.keepJigsaws)); + break; + } + case _Tag5233.sKeepAlive: { + ref wit.pumpkin.plugin.java_packets.common.SKeepAlive _payload5115 = _payload4981.getSKeepAlive(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(42); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload5115.keepAliveId)); + break; + } + case _Tag5233.sLockDifficulty: { + ref wit.pumpkin.plugin.java_packets.common.SLockDifficulty _payload5117 = _payload4981.getSLockDifficulty(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(43); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload5117.locked)); + break; + } + case _Tag5233.sMoveVehicle: { + ref wit.pumpkin.plugin.java_packets.common.SMoveVehicle _payload5119 = _payload4981.getSMoveVehicle(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(44); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload5119.x); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload5119.y); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload5119.z); + *cast(float*)(_retArea.ptr + 56) = cast(float)(_payload5119.yaw); + *cast(float*)(_retArea.ptr + 60) = cast(float)(_payload5119.pitch); + *cast(ubyte*)(_retArea.ptr + 64) = cast(ubyte)(cast(uint)(_payload5119.onGround)); + break; + } + case _Tag5233.sPaddleBoat: { + ref wit.pumpkin.plugin.java_packets.common.SPaddleBoat _payload5121 = _payload4981.getSPaddleBoat(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(45); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload5121.leftPaddle)); + *cast(ubyte*)(_retArea.ptr + 33) = cast(ubyte)(cast(uint)(_payload5121.rightPaddle)); + break; + } + case _Tag5233.sPickItemFromBlock: { + ref wit.pumpkin.plugin.java_packets.common.SPickItemFromBlock _payload5123 = _payload4981.getSPickItemFromBlock(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(46); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5123.pos[0])); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5123.pos[1])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5123.pos[2])); + *cast(ubyte*)(_retArea.ptr + 44) = cast(ubyte)(cast(uint)(_payload5123.includeData)); + break; + } + case _Tag5233.sPickItemFromEntity: { + ref wit.pumpkin.plugin.java_packets.common.SPickItemFromEntity _payload5125 = _payload4981.getSPickItemFromEntity(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(47); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5125.id)); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(cast(uint)(_payload5125.includeData)); + break; + } + case _Tag5233.sPlayPingRequest: { + ref wit.pumpkin.plugin.java_packets.common.SPlayPingRequest _payload5127 = _payload4981.getSPlayPingRequest(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(48); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload5127.payload)); + break; + } + case _Tag5233.sPlaceRecipe: { + ref wit.pumpkin.plugin.java_packets.common.SPlaceRecipe _payload5129 = _payload4981.getSPlaceRecipe(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(49); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload5129.containerId)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5129.recipeDisplayId)); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(cast(uint)(_payload5129.useMaxItems)); + break; + } + case _Tag5233.sPlayerAbilities: { + ref wit.pumpkin.plugin.java_packets.common.SPlayerAbilities _payload5131 = _payload4981.getSPlayerAbilities(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(50); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload5131.flags)); + if (_payload5131.flySpeed.isSome) { + ref _payload5135 = _payload5131.flySpeed.unwrap(); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(1); + *cast(float*)(_retArea.ptr + 40) = cast(float)(_payload5135); + } else { + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(0); + } + if (_payload5131.walkSpeed.isSome) { + ref _payload5139 = _payload5131.walkSpeed.unwrap(); + *cast(ubyte*)(_retArea.ptr + 44) = cast(ubyte)(1); + *cast(float*)(_retArea.ptr + 48) = cast(float)(_payload5139); + } else { + *cast(ubyte*)(_retArea.ptr + 44) = cast(ubyte)(0); + } + break; + } + case _Tag5233.sPlayerAction: { + ref wit.pumpkin.plugin.java_packets.common.SPlayerAction _payload5141 = _payload4981.getSPlayerAction(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(51); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5141.status)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5141.position[0])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5141.position[1])); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload5141.position[2])); + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(cast(uint)(_payload5141.face)); + *cast(uint*)(_retArea.ptr + 52) = cast(uint)(cast(uint)(_payload5141.sequence)); + break; + } + case _Tag5233.sPlayerCommand: { + ref wit.pumpkin.plugin.java_packets.common.SPlayerCommand _payload5143 = _payload4981.getSPlayerCommand(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(52); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5143.entityId)); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(cast(uint)(_payload5143.action)); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5143.jumpBoost)); + break; + } + case _Tag5233.sSetPlayerGround: { + ref wit.pumpkin.plugin.java_packets.common.SSetPlayerGround _payload5145 = _payload4981.getSSetPlayerGround(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(53); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload5145.onGround)); + break; + } + case _Tag5233.sPlayerInput: { + ref wit.pumpkin.plugin.java_packets.common.SPlayerInput _payload5147 = _payload4981.getSPlayerInput(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(54); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload5147.input)); + break; + } + case _Tag5233.sPlayerLoaded: { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(55); + break; + } + case _Tag5233.sPlayerPosition: { + ref wit.pumpkin.plugin.java_packets.common.SPlayerPosition _payload5151 = _payload4981.getSPlayerPosition(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(56); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload5151.position[0]); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload5151.position[1]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload5151.position[2]); + *cast(ubyte*)(_retArea.ptr + 56) = cast(ubyte)(cast(uint)(_payload5151.collision)); + break; + } + case _Tag5233.sPlayerPositionRotation: { + ref wit.pumpkin.plugin.java_packets.common.SPlayerPositionRotation _payload5153 = _payload4981.getSPlayerPositionRotation(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(57); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload5153.position[0]); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload5153.position[1]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload5153.position[2]); + *cast(float*)(_retArea.ptr + 56) = cast(float)(_payload5153.yaw); + *cast(float*)(_retArea.ptr + 60) = cast(float)(_payload5153.pitch); + *cast(ubyte*)(_retArea.ptr + 64) = cast(ubyte)(cast(uint)(_payload5153.collision)); + break; + } + case _Tag5233.sPlayerRotation: { + ref wit.pumpkin.plugin.java_packets.common.SPlayerRotation _payload5155 = _payload4981.getSPlayerRotation(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(58); + *cast(float*)(_retArea.ptr + 32) = cast(float)(_payload5155.yaw); + *cast(float*)(_retArea.ptr + 36) = cast(float)(_payload5155.pitch); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(cast(uint)(_payload5155.ground)); + break; + } + case _Tag5233.sPlayerSession: { + ref wit.pumpkin.plugin.java_packets.common.SPlayerSession _payload5157 = _payload4981.getSPlayerSession(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(59); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(_payload5157.sessionId.high); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(_payload5157.sessionId.low); + *cast(ulong*)(_retArea.ptr + 48) = cast(ulong)(cast(ulong)(_payload5157.expiresAt)); + *cast(size_t*)(_retArea.ptr + (56+1*size_t.sizeof)) = cast(size_t)(_payload5157.publicKey.length); + *cast(void**)(_retArea.ptr + 56) = cast(void*)(cast(void*)(_payload5157.publicKey.ptr)); + *cast(size_t*)(_retArea.ptr + (56+3*size_t.sizeof)) = cast(size_t)(_payload5157.keySignature.length); + *cast(void**)(_retArea.ptr + (56+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5157.keySignature.ptr)); + break; + } + case _Tag5233.sPlayPong: { + ref wit.pumpkin.plugin.java_packets.common.SPlayPong _payload5159 = _payload4981.getSPlayPong(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(60); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5159.id)); + break; + } + case _Tag5233.sRecipeBookChangeSettings: { + ref wit.pumpkin.plugin.java_packets.common.SRecipeBookChangeSettings _payload5161 = _payload4981.getSRecipeBookChangeSettings(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(61); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5161.bookType)); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(cast(uint)(_payload5161.isOpen)); + *cast(ubyte*)(_retArea.ptr + 37) = cast(ubyte)(cast(uint)(_payload5161.isFiltering)); + break; + } + case _Tag5233.sRecipeBookSeenRecipe: { + ref wit.pumpkin.plugin.java_packets.common.SRecipeBookSeenRecipe _payload5163 = _payload4981.getSRecipeBookSeenRecipe(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(62); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5163.recipeDisplayId)); + break; + } + case _Tag5233.sRenameItem: { + ref wit.pumpkin.plugin.java_packets.common.SRenameItem _payload5165 = _payload4981.getSRenameItem(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(63); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5165.itemName.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5165.itemName.ptr)); + break; + } + case _Tag5233.sPlayResourcePack: { + ref wit.pumpkin.plugin.java_packets.common.SPlayResourcePack _payload5167 = _payload4981.getSPlayResourcePack(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(64); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(_payload5167.uuid.high); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(_payload5167.uuid.low); + *cast(uint*)(_retArea.ptr + 48) = cast(uint)(cast(uint)(_payload5167.result)); + break; + } + case _Tag5233.sSeenAdvancement: { + ref wit.pumpkin.plugin.java_packets.common.SSeenAdvancement _payload5169 = _payload4981.getSSeenAdvancement(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(65); + alias _Tag5174 = wit.pumpkin.plugin.java_packets.common.SSeenAdvancement.Tag; + final switch (_payload5169.tag) { + case _Tag5174.openTab: { + ref WitString _payload5171 = _payload5169.getOpenTab(); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(0); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload5171.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5171.ptr)); + break; + } + case _Tag5174.closeTab: { + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(1); + break; + } + } + break; + } + case _Tag5233.sSelectTrade: { + ref wit.pumpkin.plugin.java_packets.common.SSelectTrade _payload5176 = _payload4981.getSSelectTrade(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(66); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5176.selectedSlot)); + break; + } + case _Tag5233.sSetBeacon: { + ref wit.pumpkin.plugin.java_packets.common.SSetBeacon _payload5178 = _payload4981.getSSetBeacon(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(67); + if (_payload5178.primaryEffect.isSome) { + ref _payload5182 = _payload5178.primaryEffect.unwrap(); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5182)); + } else { + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(0); + } + if (_payload5178.secondaryEffect.isSome) { + ref _payload5186 = _payload5178.secondaryEffect.unwrap(); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload5186)); + } else { + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(0); + } + break; + } + case _Tag5233.sSetCommandBlock: { + ref wit.pumpkin.plugin.java_packets.common.SSetCommandBlock _payload5188 = _payload4981.getSSetCommandBlock(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(68); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5188.pos[0])); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5188.pos[1])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5188.pos[2])); + *cast(size_t*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(size_t)(_payload5188.command.length); + *cast(void**)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5188.command.ptr)); + *cast(uint*)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5188.mode)); + *cast(ubyte*)(_retArea.ptr + (44+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5188.flags)); + break; + } + case _Tag5233.sSetCommandMinecart: { + ref wit.pumpkin.plugin.java_packets.common.SSetCommandMinecart _payload5190 = _payload4981.getSSetCommandMinecart(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(69); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5190.entityId)); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload5190.command.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5190.command.ptr)); + *cast(ubyte*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5190.trackOutput)); + break; + } + case _Tag5233.sSetCreativeSlot: { + ref wit.pumpkin.plugin.java_packets.common.SSetCreativeSlot _payload5192 = _payload4981.getSSetCreativeSlot(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(70); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5192.slot)); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload5192.clickedItem.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5192.clickedItem.ptr)); + break; + } + case _Tag5233.sSetGameRule: { + ref wit.pumpkin.plugin.java_packets.common.SSetGameRule _payload5194 = _payload4981.getSSetGameRule(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(71); + auto _listSrc5196 = _payload5194.entries; + auto _list5196 = _listSrc5196.length ? wit.common.malloc(_listSrc5196.length * ((4*size_t.sizeof))) : null; + assert(!_listSrc5196.length || _list5196); + foreach (_elem5195_idx, ref _elem5195; _listSrc5196) { + auto _base5195 = _list5196 + _elem5195_idx * ((4*size_t.sizeof)); + *cast(size_t*)(_base5195 + size_t.sizeof) = cast(size_t)(_elem5195.gameRuleKey.length); + *cast(void**)(_base5195 + 0) = cast(void*)(cast(void*)(_elem5195.gameRuleKey.ptr)); + *cast(size_t*)(_base5195 + (3*size_t.sizeof)) = cast(size_t)(_elem5195.value.length); + *cast(void**)(_base5195 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem5195.value.ptr)); + + } + if (_listSrc5196.length) wit.common.free(_listSrc5196.ptr); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5194.entries.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(_list5196); + break; + } + case _Tag5233.sSetHeldItem: { + ref wit.pumpkin.plugin.java_packets.common.SSetHeldItem _payload5198 = _payload4981.getSSetHeldItem(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(72); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5198.slot)); + break; + } + case _Tag5233.sSetJigsawBlock: { + ref wit.pumpkin.plugin.java_packets.common.SSetJigsawBlock _payload5200 = _payload4981.getSSetJigsawBlock(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(73); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5200.pos[0])); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5200.pos[1])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5200.pos[2])); + *cast(size_t*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(size_t)(_payload5200.name.length); + *cast(void**)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5200.name.ptr)); + *cast(size_t*)(_retArea.ptr + (40+4*size_t.sizeof)) = cast(size_t)(_payload5200.target.length); + *cast(void**)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5200.target.ptr)); + *cast(size_t*)(_retArea.ptr + (40+6*size_t.sizeof)) = cast(size_t)(_payload5200.pool.length); + *cast(void**)(_retArea.ptr + (40+5*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5200.pool.ptr)); + *cast(size_t*)(_retArea.ptr + (40+8*size_t.sizeof)) = cast(size_t)(_payload5200.finalState.length); + *cast(void**)(_retArea.ptr + (40+7*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5200.finalState.ptr)); + *cast(size_t*)(_retArea.ptr + (40+10*size_t.sizeof)) = cast(size_t)(_payload5200.joint.length); + *cast(void**)(_retArea.ptr + (40+9*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5200.joint.ptr)); + *cast(uint*)(_retArea.ptr + (40+11*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5200.selectionPriority)); + *cast(uint*)(_retArea.ptr + (44+11*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5200.placementPriority)); + break; + } + case _Tag5233.sSetStructureBlock: { + ref wit.pumpkin.plugin.java_packets.common.SSetStructureBlock _payload5202 = _payload4981.getSSetStructureBlock(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(74); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5202.location[0])); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5202.location[1])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5202.location[2])); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload5202.action)); + *cast(uint*)(_retArea.ptr + 48) = cast(uint)(cast(uint)(_payload5202.mode)); + *cast(size_t*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(size_t)(_payload5202.name.length); + *cast(void**)(_retArea.ptr + (48+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5202.name.ptr)); + *cast(ubyte*)(_retArea.ptr + (48+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5202.offsetX)); + *cast(ubyte*)(_retArea.ptr + (49+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5202.offsetY)); + *cast(ubyte*)(_retArea.ptr + (50+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5202.offsetZ)); + *cast(ubyte*)(_retArea.ptr + (51+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5202.sizeX)); + *cast(ubyte*)(_retArea.ptr + (52+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5202.sizeY)); + *cast(ubyte*)(_retArea.ptr + (53+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5202.sizeZ)); + *cast(uint*)(_retArea.ptr + (56+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5202.mirror)); + *cast(uint*)(_retArea.ptr + (60+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5202.rotation)); + *cast(size_t*)(_retArea.ptr + (64+4*size_t.sizeof)) = cast(size_t)(_payload5202.metadata.length); + *cast(void**)(_retArea.ptr + (64+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5202.metadata.ptr)); + *cast(float*)(_retArea.ptr + (64+5*size_t.sizeof)) = cast(float)(_payload5202.integrity); + *cast(ulong*)(_retArea.ptr + (64+6*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload5202.seed)); + *cast(ubyte*)(_retArea.ptr + (72+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5202.flags)); + break; + } + case _Tag5233.sSetTestBlock: { + ref wit.pumpkin.plugin.java_packets.common.SSetTestBlock _payload5204 = _payload4981.getSSetTestBlock(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(75); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5204.position[0])); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5204.position[1])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5204.position[2])); + *cast(ubyte*)(_retArea.ptr + 44) = cast(ubyte)(cast(uint)(_payload5204.mode)); + *cast(size_t*)(_retArea.ptr + (48+1*size_t.sizeof)) = cast(size_t)(_payload5204.message.length); + *cast(void**)(_retArea.ptr + 48) = cast(void*)(cast(void*)(_payload5204.message.ptr)); + break; + } + case _Tag5233.sSpectateEntity: { + ref wit.pumpkin.plugin.java_packets.common.SSpectateEntity _payload5206 = _payload4981.getSSpectateEntity(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(76); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(_payload5206.target.high); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(_payload5206.target.low); + break; + } + case _Tag5233.sSwingArm: { + ref wit.pumpkin.plugin.java_packets.common.SSwingArm _payload5208 = _payload4981.getSSwingArm(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(77); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5208.hand)); + break; + } + case _Tag5233.sTeleportToEntity: { + ref wit.pumpkin.plugin.java_packets.common.STeleportToEntity _payload5210 = _payload4981.getSTeleportToEntity(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(78); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(_payload5210.target.high); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(_payload5210.target.low); + break; + } + case _Tag5233.sTestInstanceBlockAction: { + ref wit.pumpkin.plugin.java_packets.common.STestInstanceBlockAction _payload5212 = _payload4981.getSTestInstanceBlockAction(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(79); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5212.pos[0])); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5212.pos[1])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5212.pos[2])); + *cast(ubyte*)(_retArea.ptr + 44) = cast(ubyte)(cast(uint)(_payload5212.action)); + if (_payload5212.data.test.isSome) { + ref _payload5216 = _payload5212.data.test.unwrap(); + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(size_t)(_payload5216.length); + *cast(void**)(_retArea.ptr + (48+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5216.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(0); + } + *cast(uint*)(_retArea.ptr + (48+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5212.data.size.x)); + *cast(uint*)(_retArea.ptr + (52+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5212.data.size.y)); + *cast(uint*)(_retArea.ptr + (56+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5212.data.size.z)); + *cast(size_t*)(_retArea.ptr + (56+5*size_t.sizeof)) = cast(size_t)(_payload5212.data.rotation.length); + *cast(void**)(_retArea.ptr + (56+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5212.data.rotation.ptr)); + *cast(ubyte*)(_retArea.ptr + (56+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5212.data.ignoreEntities)); + *cast(ubyte*)(_retArea.ptr + (57+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5212.data.status)); + if (_payload5212.data.errorMessage.isSome) { + ref _payload5220 = _payload5212.data.errorMessage.unwrap(); + *cast(ubyte*)(_retArea.ptr + (56+7*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (56+9*size_t.sizeof)) = cast(size_t)(_payload5220.length); + *cast(void**)(_retArea.ptr + (56+8*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5220.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (56+7*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag5233.sUpdateSign: { + ref wit.pumpkin.plugin.java_packets.common.SUpdateSign _payload5222 = _payload4981.getSUpdateSign(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(80); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5222.location[0])); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5222.location[1])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5222.location[2])); + *cast(ubyte*)(_retArea.ptr + 44) = cast(ubyte)(cast(uint)(_payload5222.isFrontText)); + *cast(size_t*)(_retArea.ptr + (48+1*size_t.sizeof)) = cast(size_t)(_payload5222.line1.length); + *cast(void**)(_retArea.ptr + 48) = cast(void*)(cast(void*)(_payload5222.line1.ptr)); + *cast(size_t*)(_retArea.ptr + (48+3*size_t.sizeof)) = cast(size_t)(_payload5222.line2.length); + *cast(void**)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5222.line2.ptr)); + *cast(size_t*)(_retArea.ptr + (48+5*size_t.sizeof)) = cast(size_t)(_payload5222.line3.length); + *cast(void**)(_retArea.ptr + (48+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5222.line3.ptr)); + *cast(size_t*)(_retArea.ptr + (48+7*size_t.sizeof)) = cast(size_t)(_payload5222.line4.length); + *cast(void**)(_retArea.ptr + (48+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5222.line4.ptr)); + break; + } + case _Tag5233.sUseItem: { + ref wit.pumpkin.plugin.java_packets.common.SUseItem _payload5224 = _payload4981.getSUseItem(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(81); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5224.hand)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5224.sequence)); + *cast(float*)(_retArea.ptr + 40) = cast(float)(_payload5224.yaw); + *cast(float*)(_retArea.ptr + 44) = cast(float)(_payload5224.pitch); + break; + } + case _Tag5233.sUseItemOn: { + ref wit.pumpkin.plugin.java_packets.common.SUseItemOn _payload5226 = _payload4981.getSUseItemOn(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(82); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5226.hand)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5226.position[0])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5226.position[1])); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload5226.position[2])); + *cast(uint*)(_retArea.ptr + 48) = cast(uint)(cast(uint)(_payload5226.face)); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload5226.cursorPos[0]); + *cast(double*)(_retArea.ptr + 64) = cast(double)(_payload5226.cursorPos[1]); + *cast(double*)(_retArea.ptr + 72) = cast(double)(_payload5226.cursorPos[2]); + *cast(ubyte*)(_retArea.ptr + 80) = cast(ubyte)(cast(uint)(_payload5226.insideBlock)); + *cast(ubyte*)(_retArea.ptr + 81) = cast(ubyte)(cast(uint)(_payload5226.isAgainstWorldBorder)); + *cast(uint*)(_retArea.ptr + 84) = cast(uint)(cast(uint)(_payload5226.sequence)); + break; + } + case _Tag5233.statusSStatusPingRequest: { + ref wit.pumpkin.plugin.java_packets.common.StatusSStatusPingRequest _payload5228 = _payload4981.getStatusSStatusPingRequest(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(83); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload5228.payload)); + break; + } + case _Tag5233.statusSStatusRequest: { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(84); + break; + } + case _Tag5233.unknown: { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(85); + break; + } + } + break; + } + case _Tag5593.bedrock: { + ref wit.pumpkin.plugin.event.common.BedrockServerboundPacket _payload5235 = _payload4979.packet.getBedrock(); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(1); + alias _Tag5590 = wit.pumpkin.plugin.bedrock_packets.common.ServerboundPacket.Tag; + final switch (_payload5235.tag) { + case _Tag5590.sActorEvent: { + ref wit.pumpkin.plugin.bedrock_packets.common.SActorEvent _payload5237 = _payload5235.getSActorEvent(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(0); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload5237.targetRuntimeId)); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(cast(uint)(_payload5237.eventId)); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload5237.data)); + if (_payload5237.fireAtPosition.isSome) { + ref _payload5241 = _payload5237.fireAtPosition.unwrap(); + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(1); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload5241[0]); + *cast(double*)(_retArea.ptr + 64) = cast(double)(_payload5241[1]); + *cast(double*)(_retArea.ptr + 72) = cast(double)(_payload5241[2]); + } else { + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(0); + } + break; + } + case _Tag5590.sAnimate: { + ref wit.pumpkin.plugin.bedrock_packets.common.SAnimate _payload5243 = _payload5235.getSAnimate(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(1); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload5243.action)); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(cast(ulong)(_payload5243.targetActorRuntimeId)); + *cast(float*)(_retArea.ptr + 48) = cast(float)(_payload5243.data); + if (_payload5243.swingSource.isSome) { + ref _payload5247 = _payload5243.swingSource.unwrap(); + *cast(ubyte*)(_retArea.ptr + 52) = cast(ubyte)(1); + *cast(ubyte*)(_retArea.ptr + 53) = cast(ubyte)(cast(uint)(_payload5247)); + } else { + *cast(ubyte*)(_retArea.ptr + 52) = cast(ubyte)(0); + } + break; + } + case _Tag5590.sBlockPickRequest: { + ref wit.pumpkin.plugin.bedrock_packets.common.SBlockPickRequest _payload5249 = _payload5235.getSBlockPickRequest(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(2); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5249.position[0])); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5249.position[1])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5249.position[2])); + *cast(ubyte*)(_retArea.ptr + 44) = cast(ubyte)(cast(uint)(_payload5249.withData)); + *cast(ubyte*)(_retArea.ptr + 45) = cast(ubyte)(cast(uint)(_payload5249.maxSlots)); + break; + } + case _Tag5590.sClientCacheBlobStatus: { + ref wit.pumpkin.plugin.bedrock_packets.common.SClientCacheBlobStatus _payload5251 = _payload5235.getSClientCacheBlobStatus(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(3); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5251.missHashes.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5251.missHashes.ptr)); + *cast(size_t*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(size_t)(_payload5251.hitHashes.length); + *cast(void**)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5251.hitHashes.ptr)); + break; + } + case _Tag5590.sClientCacheStatus: { + ref wit.pumpkin.plugin.bedrock_packets.common.SClientCacheStatus _payload5253 = _payload5235.getSClientCacheStatus(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(4); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload5253.isCacheSupported)); + break; + } + case _Tag5590.sCommandRequest: { + ref wit.pumpkin.plugin.bedrock_packets.common.SCommandRequest _payload5255 = _payload5235.getSCommandRequest(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(5); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5255.command.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5255.command.ptr)); + *cast(size_t*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(size_t)(_payload5255.origin.rType.length); + *cast(void**)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5255.origin.rType.ptr)); + *cast(ulong*)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(ulong)(_payload5255.origin.uuid.high); + *cast(ulong*)(_retArea.ptr + (40+4*size_t.sizeof)) = cast(ulong)(_payload5255.origin.uuid.low); + *cast(size_t*)(_retArea.ptr + (48+5*size_t.sizeof)) = cast(size_t)(_payload5255.origin.requestId.length); + *cast(void**)(_retArea.ptr + (48+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5255.origin.requestId.ptr)); + *cast(ulong*)(_retArea.ptr + (48+6*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload5255.origin.playerId)); + *cast(ubyte*)(_retArea.ptr + (56+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5255.isInternal)); + *cast(size_t*)(_retArea.ptr + (56+8*size_t.sizeof)) = cast(size_t)(_payload5255.version_.length); + *cast(void**)(_retArea.ptr + (56+7*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5255.version_.ptr)); + break; + } + case _Tag5590.sContainerClose: { + ref wit.pumpkin.plugin.bedrock_packets.common.SContainerClose _payload5257 = _payload5235.getSContainerClose(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(6); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload5257.containerId)); + *cast(ubyte*)(_retArea.ptr + 33) = cast(ubyte)(cast(uint)(_payload5257.containerType)); + *cast(ubyte*)(_retArea.ptr + 34) = cast(ubyte)(cast(uint)(_payload5257.serverInitiatedClose)); + break; + } + case _Tag5590.sEmote: { + ref wit.pumpkin.plugin.bedrock_packets.common.SEmote _payload5259 = _payload5235.getSEmote(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(7); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload5259.actorRuntimeId)); + *cast(size_t*)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(size_t)(_payload5259.emoteId.length); + *cast(void**)(_retArea.ptr + 40) = cast(void*)(cast(void*)(_payload5259.emoteId.ptr)); + *cast(uint*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5259.emoteLengthTicks)); + *cast(size_t*)(_retArea.ptr + (40+4*size_t.sizeof)) = cast(size_t)(_payload5259.xuid.length); + *cast(void**)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5259.xuid.ptr)); + *cast(size_t*)(_retArea.ptr + (40+6*size_t.sizeof)) = cast(size_t)(_payload5259.platformId.length); + *cast(void**)(_retArea.ptr + (40+5*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5259.platformId.ptr)); + *cast(ubyte*)(_retArea.ptr + (40+7*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5259.flags)); + break; + } + case _Tag5590.sEmoteList: { + ref wit.pumpkin.plugin.bedrock_packets.common.SEmoteList _payload5261 = _payload5235.getSEmoteList(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(8); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload5261.runtimeId)); + *cast(size_t*)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(size_t)(_payload5261.emotePieceIds.length); + *cast(void**)(_retArea.ptr + 40) = cast(void*)(cast(void*)(_payload5261.emotePieceIds.ptr)); + break; + } + case _Tag5590.sInteract: { + ref wit.pumpkin.plugin.bedrock_packets.common.SInteract _payload5263 = _payload5235.getSInteract(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(9); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload5263.action)); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(cast(ulong)(_payload5263.targetRuntimeId)); + if (_payload5263.position.isSome) { + ref _payload5267 = _payload5263.position.unwrap(); + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(1); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload5267[0]); + *cast(double*)(_retArea.ptr + 64) = cast(double)(_payload5267[1]); + *cast(double*)(_retArea.ptr + 72) = cast(double)(_payload5267[2]); + } else { + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(0); + } + break; + } + case _Tag5590.sInventoryTransaction: { + ref wit.pumpkin.plugin.bedrock_packets.common.SInventoryTransaction _payload5269 = _payload5235.getSInventoryTransaction(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(10); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5269.legacyRequestId)); + auto _listSrc5271 = _payload5269.legacySetItemSlots; + auto _list5271 = _listSrc5271.length ? wit.common.malloc(_listSrc5271.length * ((3*size_t.sizeof))) : null; + assert(!_listSrc5271.length || _list5271); + foreach (_elem5270_idx, ref _elem5270; _listSrc5271) { + auto _base5270 = _list5271 + _elem5270_idx * ((3*size_t.sizeof)); + *cast(ubyte*)(_base5270 + 0) = cast(ubyte)(cast(uint)(_elem5270.containerId)); + *cast(size_t*)(_base5270 + (2*size_t.sizeof)) = cast(size_t)(_elem5270.slots.length); + *cast(void**)(_base5270 + size_t.sizeof) = cast(void*)(cast(void*)(_elem5270.slots.ptr)); + + } + if (_listSrc5271.length) wit.common.free(_listSrc5271.ptr); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload5269.legacySetItemSlots.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(_list5271); + *cast(ubyte*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5269.hasValue)); + auto _listSrc5289 = _payload5269.actions; + auto _list5289 = _listSrc5289.length ? wit.common.malloc(_listSrc5289.length * ((72+12*size_t.sizeof))) : null; + assert(!_listSrc5289.length || _list5289); + foreach (_elem5272_idx, ref _elem5272; _listSrc5289) { + auto _base5272 = _list5289 + _elem5272_idx * ((72+12*size_t.sizeof)); + *cast(uint*)(_base5272 + 0) = cast(uint)(cast(uint)(_elem5272.sourceType)); + if (_elem5272.windowId.isSome) { + ref _payload5276 = _elem5272.windowId.unwrap(); + *cast(ubyte*)(_base5272 + 4) = cast(ubyte)(1); + *cast(uint*)(_base5272 + 8) = cast(uint)(cast(uint)(_payload5276)); + } else { + *cast(ubyte*)(_base5272 + 4) = cast(ubyte)(0); + } + if (_elem5272.sourceFlags.isSome) { + ref _payload5280 = _elem5272.sourceFlags.unwrap(); + *cast(ubyte*)(_base5272 + 12) = cast(ubyte)(1); + *cast(uint*)(_base5272 + 16) = cast(uint)(cast(uint)(_payload5280)); + } else { + *cast(ubyte*)(_base5272 + 12) = cast(ubyte)(0); + } + *cast(uint*)(_base5272 + 20) = cast(uint)(cast(uint)(_elem5272.inventorySlot)); + *cast(uint*)(_base5272 + 24) = cast(uint)(cast(uint)(_elem5272.oldItem.id)); + *cast(uint*)(_base5272 + 28) = cast(uint)(cast(uint)(_elem5272.oldItem.stackSize)); + *cast(uint*)(_base5272 + 32) = cast(uint)(cast(uint)(_elem5272.oldItem.auxValue)); + *cast(uint*)(_base5272 + 36) = cast(uint)(cast(uint)(_elem5272.oldItem.blockRuntimeId)); + *cast(size_t*)(_base5272 + (40+1*size_t.sizeof)) = cast(size_t)(_elem5272.oldItem.nbtData.length); + *cast(void**)(_base5272 + 40) = cast(void*)(cast(void*)(_elem5272.oldItem.nbtData.ptr)); + auto _listSrc5282 = _elem5272.oldItem.placeOnBlocks; + auto _list5282 = _listSrc5282.length ? wit.common.malloc(_listSrc5282.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5282.length || _list5282); + foreach (_elem5281_idx, ref _elem5281; _listSrc5282) { + auto _base5281 = _list5282 + _elem5281_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5281 + size_t.sizeof) = cast(size_t)(_elem5281.length); + *cast(void**)(_base5281 + 0) = cast(void*)(cast(void*)(_elem5281.ptr)); + + } + if (_listSrc5282.length) wit.common.free(_listSrc5282.ptr); + *cast(size_t*)(_base5272 + (40+3*size_t.sizeof)) = cast(size_t)(_elem5272.oldItem.placeOnBlocks.length); + *cast(void**)(_base5272 + (40+2*size_t.sizeof)) = cast(void*)(_list5282); + auto _listSrc5284 = _elem5272.oldItem.destroyBlocks; + auto _list5284 = _listSrc5284.length ? wit.common.malloc(_listSrc5284.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5284.length || _list5284); + foreach (_elem5283_idx, ref _elem5283; _listSrc5284) { + auto _base5283 = _list5284 + _elem5283_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5283 + size_t.sizeof) = cast(size_t)(_elem5283.length); + *cast(void**)(_base5283 + 0) = cast(void*)(cast(void*)(_elem5283.ptr)); + + } + if (_listSrc5284.length) wit.common.free(_listSrc5284.ptr); + *cast(size_t*)(_base5272 + (40+5*size_t.sizeof)) = cast(size_t)(_elem5272.oldItem.destroyBlocks.length); + *cast(void**)(_base5272 + (40+4*size_t.sizeof)) = cast(void*)(_list5284); + *cast(ulong*)(_base5272 + (40+6*size_t.sizeof)) = cast(ulong)(cast(ulong)(_elem5272.oldItem.shieldBlockingTick)); + *cast(uint*)(_base5272 + (48+6*size_t.sizeof)) = cast(uint)(cast(uint)(_elem5272.newItem.id)); + *cast(uint*)(_base5272 + (52+6*size_t.sizeof)) = cast(uint)(cast(uint)(_elem5272.newItem.stackSize)); + *cast(uint*)(_base5272 + (56+6*size_t.sizeof)) = cast(uint)(cast(uint)(_elem5272.newItem.auxValue)); + *cast(uint*)(_base5272 + (60+6*size_t.sizeof)) = cast(uint)(cast(uint)(_elem5272.newItem.blockRuntimeId)); + *cast(size_t*)(_base5272 + (64+7*size_t.sizeof)) = cast(size_t)(_elem5272.newItem.nbtData.length); + *cast(void**)(_base5272 + (64+6*size_t.sizeof)) = cast(void*)(cast(void*)(_elem5272.newItem.nbtData.ptr)); + auto _listSrc5286 = _elem5272.newItem.placeOnBlocks; + auto _list5286 = _listSrc5286.length ? wit.common.malloc(_listSrc5286.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5286.length || _list5286); + foreach (_elem5285_idx, ref _elem5285; _listSrc5286) { + auto _base5285 = _list5286 + _elem5285_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5285 + size_t.sizeof) = cast(size_t)(_elem5285.length); + *cast(void**)(_base5285 + 0) = cast(void*)(cast(void*)(_elem5285.ptr)); + + } + if (_listSrc5286.length) wit.common.free(_listSrc5286.ptr); + *cast(size_t*)(_base5272 + (64+9*size_t.sizeof)) = cast(size_t)(_elem5272.newItem.placeOnBlocks.length); + *cast(void**)(_base5272 + (64+8*size_t.sizeof)) = cast(void*)(_list5286); + auto _listSrc5288 = _elem5272.newItem.destroyBlocks; + auto _list5288 = _listSrc5288.length ? wit.common.malloc(_listSrc5288.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5288.length || _list5288); + foreach (_elem5287_idx, ref _elem5287; _listSrc5288) { + auto _base5287 = _list5288 + _elem5287_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5287 + size_t.sizeof) = cast(size_t)(_elem5287.length); + *cast(void**)(_base5287 + 0) = cast(void*)(cast(void*)(_elem5287.ptr)); + + } + if (_listSrc5288.length) wit.common.free(_listSrc5288.ptr); + *cast(size_t*)(_base5272 + (64+11*size_t.sizeof)) = cast(size_t)(_elem5272.newItem.destroyBlocks.length); + *cast(void**)(_base5272 + (64+10*size_t.sizeof)) = cast(void*)(_list5288); + *cast(ulong*)(_base5272 + (64+12*size_t.sizeof)) = cast(ulong)(cast(ulong)(_elem5272.newItem.shieldBlockingTick)); + + } + if (_listSrc5289.length) wit.common.free(_listSrc5289.ptr); + *cast(size_t*)(_retArea.ptr + (32+5*size_t.sizeof)) = cast(size_t)(_payload5269.actions.length); + *cast(void**)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(void*)(_list5289); + *cast(uint*)(_retArea.ptr + (32+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5269.transactionType)); + alias _Tag5312 = wit.pumpkin.plugin.bedrock_packets.common.TransactionData.Tag; + final switch (_payload5269.transactionData.tag) { + case _Tag5312.normal: { + ref WitString _payload5291 = _payload5269.transactionData.getNormal(); + *cast(ubyte*)(_retArea.ptr + (40+6*size_t.sizeof)) = cast(ubyte)(0); + *cast(size_t*)(_retArea.ptr + (48+7*size_t.sizeof)) = cast(size_t)(_payload5291.length); + *cast(void**)(_retArea.ptr + (48+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5291.ptr)); + break; + } + case _Tag5312.mismatch: { + ref WitString _payload5293 = _payload5269.transactionData.getMismatch(); + *cast(ubyte*)(_retArea.ptr + (40+6*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (48+7*size_t.sizeof)) = cast(size_t)(_payload5293.length); + *cast(void**)(_retArea.ptr + (48+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5293.ptr)); + break; + } + case _Tag5312.useItem: { + ref wit.pumpkin.plugin.bedrock_packets.common.UseItemTransactionData _payload5295 = _payload5269.transactionData.getUseItem(); + *cast(ubyte*)(_retArea.ptr + (40+6*size_t.sizeof)) = cast(ubyte)(2); + *cast(uint*)(_retArea.ptr + (48+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5295.actionType)); + *cast(ubyte*)(_retArea.ptr + (52+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5295.triggerType)); + *cast(uint*)(_retArea.ptr + (56+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5295.blockPosition[0])); + *cast(uint*)(_retArea.ptr + (60+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5295.blockPosition[1])); + *cast(uint*)(_retArea.ptr + (64+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5295.blockPosition[2])); + *cast(ubyte*)(_retArea.ptr + (68+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5295.blockFace)); + *cast(uint*)(_retArea.ptr + (72+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5295.hotBarSlot)); + *cast(uint*)(_retArea.ptr + (80+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5295.itemInHand.id)); + *cast(uint*)(_retArea.ptr + (84+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5295.itemInHand.stackSize)); + *cast(uint*)(_retArea.ptr + (88+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5295.itemInHand.auxValue)); + *cast(uint*)(_retArea.ptr + (92+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5295.itemInHand.blockRuntimeId)); + *cast(size_t*)(_retArea.ptr + (96+7*size_t.sizeof)) = cast(size_t)(_payload5295.itemInHand.nbtData.length); + *cast(void**)(_retArea.ptr + (96+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5295.itemInHand.nbtData.ptr)); + auto _listSrc5297 = _payload5295.itemInHand.placeOnBlocks; + auto _list5297 = _listSrc5297.length ? wit.common.malloc(_listSrc5297.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5297.length || _list5297); + foreach (_elem5296_idx, ref _elem5296; _listSrc5297) { + auto _base5296 = _list5297 + _elem5296_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5296 + size_t.sizeof) = cast(size_t)(_elem5296.length); + *cast(void**)(_base5296 + 0) = cast(void*)(cast(void*)(_elem5296.ptr)); + + } + if (_listSrc5297.length) wit.common.free(_listSrc5297.ptr); + *cast(size_t*)(_retArea.ptr + (96+9*size_t.sizeof)) = cast(size_t)(_payload5295.itemInHand.placeOnBlocks.length); + *cast(void**)(_retArea.ptr + (96+8*size_t.sizeof)) = cast(void*)(_list5297); + auto _listSrc5299 = _payload5295.itemInHand.destroyBlocks; + auto _list5299 = _listSrc5299.length ? wit.common.malloc(_listSrc5299.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5299.length || _list5299); + foreach (_elem5298_idx, ref _elem5298; _listSrc5299) { + auto _base5298 = _list5299 + _elem5298_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5298 + size_t.sizeof) = cast(size_t)(_elem5298.length); + *cast(void**)(_base5298 + 0) = cast(void*)(cast(void*)(_elem5298.ptr)); + + } + if (_listSrc5299.length) wit.common.free(_listSrc5299.ptr); + *cast(size_t*)(_retArea.ptr + (96+11*size_t.sizeof)) = cast(size_t)(_payload5295.itemInHand.destroyBlocks.length); + *cast(void**)(_retArea.ptr + (96+10*size_t.sizeof)) = cast(void*)(_list5299); + *cast(ulong*)(_retArea.ptr + (96+12*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload5295.itemInHand.shieldBlockingTick)); + *cast(double*)(_retArea.ptr + (104+12*size_t.sizeof)) = cast(double)(_payload5295.playerPosition[0]); + *cast(double*)(_retArea.ptr + (112+12*size_t.sizeof)) = cast(double)(_payload5295.playerPosition[1]); + *cast(double*)(_retArea.ptr + (120+12*size_t.sizeof)) = cast(double)(_payload5295.playerPosition[2]); + *cast(double*)(_retArea.ptr + (128+12*size_t.sizeof)) = cast(double)(_payload5295.clickPosition[0]); + *cast(double*)(_retArea.ptr + (136+12*size_t.sizeof)) = cast(double)(_payload5295.clickPosition[1]); + *cast(double*)(_retArea.ptr + (144+12*size_t.sizeof)) = cast(double)(_payload5295.clickPosition[2]); + *cast(uint*)(_retArea.ptr + (152+12*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5295.blockRuntimeId)); + *cast(ubyte*)(_retArea.ptr + (156+12*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5295.clientPrediction)); + *cast(ubyte*)(_retArea.ptr + (157+12*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5295.clientCooldownState)); + break; + } + case _Tag5312.useItemOnEntity: { + ref wit.pumpkin.plugin.bedrock_packets.common.UseItemOnEntityTransactionData _payload5301 = _payload5269.transactionData.getUseItemOnEntity(); + *cast(ubyte*)(_retArea.ptr + (40+6*size_t.sizeof)) = cast(ubyte)(3); + *cast(ulong*)(_retArea.ptr + (48+6*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload5301.targetEntityRuntimeId)); + *cast(uint*)(_retArea.ptr + (56+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5301.actionType)); + *cast(uint*)(_retArea.ptr + (60+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5301.hotBarSlot)); + *cast(uint*)(_retArea.ptr + (64+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5301.itemInHand.id)); + *cast(uint*)(_retArea.ptr + (68+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5301.itemInHand.stackSize)); + *cast(uint*)(_retArea.ptr + (72+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5301.itemInHand.auxValue)); + *cast(uint*)(_retArea.ptr + (76+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5301.itemInHand.blockRuntimeId)); + *cast(size_t*)(_retArea.ptr + (80+7*size_t.sizeof)) = cast(size_t)(_payload5301.itemInHand.nbtData.length); + *cast(void**)(_retArea.ptr + (80+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5301.itemInHand.nbtData.ptr)); + auto _listSrc5303 = _payload5301.itemInHand.placeOnBlocks; + auto _list5303 = _listSrc5303.length ? wit.common.malloc(_listSrc5303.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5303.length || _list5303); + foreach (_elem5302_idx, ref _elem5302; _listSrc5303) { + auto _base5302 = _list5303 + _elem5302_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5302 + size_t.sizeof) = cast(size_t)(_elem5302.length); + *cast(void**)(_base5302 + 0) = cast(void*)(cast(void*)(_elem5302.ptr)); + + } + if (_listSrc5303.length) wit.common.free(_listSrc5303.ptr); + *cast(size_t*)(_retArea.ptr + (80+9*size_t.sizeof)) = cast(size_t)(_payload5301.itemInHand.placeOnBlocks.length); + *cast(void**)(_retArea.ptr + (80+8*size_t.sizeof)) = cast(void*)(_list5303); + auto _listSrc5305 = _payload5301.itemInHand.destroyBlocks; + auto _list5305 = _listSrc5305.length ? wit.common.malloc(_listSrc5305.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5305.length || _list5305); + foreach (_elem5304_idx, ref _elem5304; _listSrc5305) { + auto _base5304 = _list5305 + _elem5304_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5304 + size_t.sizeof) = cast(size_t)(_elem5304.length); + *cast(void**)(_base5304 + 0) = cast(void*)(cast(void*)(_elem5304.ptr)); + + } + if (_listSrc5305.length) wit.common.free(_listSrc5305.ptr); + *cast(size_t*)(_retArea.ptr + (80+11*size_t.sizeof)) = cast(size_t)(_payload5301.itemInHand.destroyBlocks.length); + *cast(void**)(_retArea.ptr + (80+10*size_t.sizeof)) = cast(void*)(_list5305); + *cast(ulong*)(_retArea.ptr + (80+12*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload5301.itemInHand.shieldBlockingTick)); + *cast(double*)(_retArea.ptr + (88+12*size_t.sizeof)) = cast(double)(_payload5301.playerPosition[0]); + *cast(double*)(_retArea.ptr + (96+12*size_t.sizeof)) = cast(double)(_payload5301.playerPosition[1]); + *cast(double*)(_retArea.ptr + (104+12*size_t.sizeof)) = cast(double)(_payload5301.playerPosition[2]); + *cast(double*)(_retArea.ptr + (112+12*size_t.sizeof)) = cast(double)(_payload5301.clickPosition[0]); + *cast(double*)(_retArea.ptr + (120+12*size_t.sizeof)) = cast(double)(_payload5301.clickPosition[1]); + *cast(double*)(_retArea.ptr + (128+12*size_t.sizeof)) = cast(double)(_payload5301.clickPosition[2]); + break; + } + case _Tag5312.releaseItem: { + ref wit.pumpkin.plugin.bedrock_packets.common.ReleaseItemTransactionData _payload5307 = _payload5269.transactionData.getReleaseItem(); + *cast(ubyte*)(_retArea.ptr + (40+6*size_t.sizeof)) = cast(ubyte)(4); + *cast(uint*)(_retArea.ptr + (48+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5307.actionType)); + *cast(uint*)(_retArea.ptr + (52+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5307.hotBarSlot)); + *cast(uint*)(_retArea.ptr + (56+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5307.itemInHand.id)); + *cast(uint*)(_retArea.ptr + (60+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5307.itemInHand.stackSize)); + *cast(uint*)(_retArea.ptr + (64+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5307.itemInHand.auxValue)); + *cast(uint*)(_retArea.ptr + (68+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5307.itemInHand.blockRuntimeId)); + *cast(size_t*)(_retArea.ptr + (72+7*size_t.sizeof)) = cast(size_t)(_payload5307.itemInHand.nbtData.length); + *cast(void**)(_retArea.ptr + (72+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5307.itemInHand.nbtData.ptr)); + auto _listSrc5309 = _payload5307.itemInHand.placeOnBlocks; + auto _list5309 = _listSrc5309.length ? wit.common.malloc(_listSrc5309.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5309.length || _list5309); + foreach (_elem5308_idx, ref _elem5308; _listSrc5309) { + auto _base5308 = _list5309 + _elem5308_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5308 + size_t.sizeof) = cast(size_t)(_elem5308.length); + *cast(void**)(_base5308 + 0) = cast(void*)(cast(void*)(_elem5308.ptr)); + + } + if (_listSrc5309.length) wit.common.free(_listSrc5309.ptr); + *cast(size_t*)(_retArea.ptr + (72+9*size_t.sizeof)) = cast(size_t)(_payload5307.itemInHand.placeOnBlocks.length); + *cast(void**)(_retArea.ptr + (72+8*size_t.sizeof)) = cast(void*)(_list5309); + auto _listSrc5311 = _payload5307.itemInHand.destroyBlocks; + auto _list5311 = _listSrc5311.length ? wit.common.malloc(_listSrc5311.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5311.length || _list5311); + foreach (_elem5310_idx, ref _elem5310; _listSrc5311) { + auto _base5310 = _list5311 + _elem5310_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5310 + size_t.sizeof) = cast(size_t)(_elem5310.length); + *cast(void**)(_base5310 + 0) = cast(void*)(cast(void*)(_elem5310.ptr)); + + } + if (_listSrc5311.length) wit.common.free(_listSrc5311.ptr); + *cast(size_t*)(_retArea.ptr + (72+11*size_t.sizeof)) = cast(size_t)(_payload5307.itemInHand.destroyBlocks.length); + *cast(void**)(_retArea.ptr + (72+10*size_t.sizeof)) = cast(void*)(_list5311); + *cast(ulong*)(_retArea.ptr + (72+12*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload5307.itemInHand.shieldBlockingTick)); + *cast(double*)(_retArea.ptr + (80+12*size_t.sizeof)) = cast(double)(_payload5307.headPosition[0]); + *cast(double*)(_retArea.ptr + (88+12*size_t.sizeof)) = cast(double)(_payload5307.headPosition[1]); + *cast(double*)(_retArea.ptr + (96+12*size_t.sizeof)) = cast(double)(_payload5307.headPosition[2]); + break; + } + } + break; + } + case _Tag5590.sItemStackRequest: { + ref wit.pumpkin.plugin.bedrock_packets.common.SItemStackRequest _payload5314 = _payload5235.getSItemStackRequest(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(11); + auto _listSrc5399 = _payload5314.requests; + auto _list5399 = _listSrc5399.length ? wit.common.malloc(_listSrc5399.length * ((6*size_t.sizeof))) : null; + assert(!_listSrc5399.length || _list5399); + foreach (_elem5315_idx, ref _elem5315; _listSrc5399) { + auto _base5315 = _list5399 + _elem5315_idx * ((6*size_t.sizeof)); + *cast(uint*)(_base5315 + 0) = cast(uint)(cast(uint)(_elem5315.requestId)); + auto _listSrc5396 = _elem5315.actions; + auto _list5396 = _listSrc5396.length ? wit.common.malloc(_listSrc5396.length * ((40+2*size_t.sizeof))) : null; + assert(!_listSrc5396.length || _list5396); + foreach (_elem5316_idx, ref _elem5316; _listSrc5396) { + auto _base5316 = _list5396 + _elem5316_idx * ((40+2*size_t.sizeof)); + alias _Tag5395 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.Tag; + final switch (_elem5316.tag) { + case _Tag5395.take: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionTake _payload5318 = _elem5316.getTake(); + *cast(ubyte*)(_base5316 + 0) = cast(ubyte)(0); + *cast(ubyte*)(_base5316 + size_t.sizeof) = cast(ubyte)(cast(uint)(_payload5318.count)); + *cast(ubyte*)(_base5316 + (4+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5318.source.containerName.containerName)); + if (_payload5318.source.containerName.dynamicId.isSome) { + ref _payload5322 = _payload5318.source.containerName.dynamicId.unwrap(); + *cast(ubyte*)(_base5316 + (8+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base5316 + (12+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5322)); + } else { + *cast(ubyte*)(_base5316 + (8+1*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base5316 + (16+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5318.source.slotId)); + *cast(uint*)(_base5316 + (20+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5318.source.stackId)); + *cast(ubyte*)(_base5316 + (24+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5318.destination.containerName.containerName)); + if (_payload5318.destination.containerName.dynamicId.isSome) { + ref _payload5326 = _payload5318.destination.containerName.dynamicId.unwrap(); + *cast(ubyte*)(_base5316 + (28+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base5316 + (32+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5326)); + } else { + *cast(ubyte*)(_base5316 + (28+1*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base5316 + (36+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5318.destination.slotId)); + *cast(uint*)(_base5316 + (40+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5318.destination.stackId)); + break; + } + case _Tag5395.place: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionPlace _payload5328 = _elem5316.getPlace(); + *cast(ubyte*)(_base5316 + 0) = cast(ubyte)(1); + *cast(ubyte*)(_base5316 + size_t.sizeof) = cast(ubyte)(cast(uint)(_payload5328.count)); + *cast(ubyte*)(_base5316 + (4+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5328.source.containerName.containerName)); + if (_payload5328.source.containerName.dynamicId.isSome) { + ref _payload5332 = _payload5328.source.containerName.dynamicId.unwrap(); + *cast(ubyte*)(_base5316 + (8+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base5316 + (12+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5332)); + } else { + *cast(ubyte*)(_base5316 + (8+1*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base5316 + (16+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5328.source.slotId)); + *cast(uint*)(_base5316 + (20+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5328.source.stackId)); + *cast(ubyte*)(_base5316 + (24+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5328.destination.containerName.containerName)); + if (_payload5328.destination.containerName.dynamicId.isSome) { + ref _payload5336 = _payload5328.destination.containerName.dynamicId.unwrap(); + *cast(ubyte*)(_base5316 + (28+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base5316 + (32+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5336)); + } else { + *cast(ubyte*)(_base5316 + (28+1*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base5316 + (36+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5328.destination.slotId)); + *cast(uint*)(_base5316 + (40+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5328.destination.stackId)); + break; + } + case _Tag5395.swap: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionSwap _payload5338 = _elem5316.getSwap(); + *cast(ubyte*)(_base5316 + 0) = cast(ubyte)(2); + *cast(ubyte*)(_base5316 + size_t.sizeof) = cast(ubyte)(cast(uint)(_payload5338.slot1.containerName.containerName)); + if (_payload5338.slot1.containerName.dynamicId.isSome) { + ref _payload5342 = _payload5338.slot1.containerName.dynamicId.unwrap(); + *cast(ubyte*)(_base5316 + (4+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base5316 + (8+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5342)); + } else { + *cast(ubyte*)(_base5316 + (4+1*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base5316 + (12+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5338.slot1.slotId)); + *cast(uint*)(_base5316 + (16+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5338.slot1.stackId)); + *cast(ubyte*)(_base5316 + (20+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5338.slot2.containerName.containerName)); + if (_payload5338.slot2.containerName.dynamicId.isSome) { + ref _payload5346 = _payload5338.slot2.containerName.dynamicId.unwrap(); + *cast(ubyte*)(_base5316 + (24+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base5316 + (28+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5346)); + } else { + *cast(ubyte*)(_base5316 + (24+1*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base5316 + (32+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5338.slot2.slotId)); + *cast(uint*)(_base5316 + (36+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5338.slot2.stackId)); + break; + } + case _Tag5395.drop: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionDrop _payload5348 = _elem5316.getDrop(); + *cast(ubyte*)(_base5316 + 0) = cast(ubyte)(3); + *cast(ubyte*)(_base5316 + size_t.sizeof) = cast(ubyte)(cast(uint)(_payload5348.count)); + *cast(ubyte*)(_base5316 + (4+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5348.source.containerName.containerName)); + if (_payload5348.source.containerName.dynamicId.isSome) { + ref _payload5352 = _payload5348.source.containerName.dynamicId.unwrap(); + *cast(ubyte*)(_base5316 + (8+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base5316 + (12+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5352)); + } else { + *cast(ubyte*)(_base5316 + (8+1*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base5316 + (16+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5348.source.slotId)); + *cast(uint*)(_base5316 + (20+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5348.source.stackId)); + *cast(ubyte*)(_base5316 + (24+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5348.randomly)); + break; + } + case _Tag5395.destroy: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionDestroy _payload5354 = _elem5316.getDestroy(); + *cast(ubyte*)(_base5316 + 0) = cast(ubyte)(4); + *cast(ubyte*)(_base5316 + size_t.sizeof) = cast(ubyte)(cast(uint)(_payload5354.count)); + *cast(ubyte*)(_base5316 + (4+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5354.source.containerName.containerName)); + if (_payload5354.source.containerName.dynamicId.isSome) { + ref _payload5358 = _payload5354.source.containerName.dynamicId.unwrap(); + *cast(ubyte*)(_base5316 + (8+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base5316 + (12+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5358)); + } else { + *cast(ubyte*)(_base5316 + (8+1*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base5316 + (16+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5354.source.slotId)); + *cast(uint*)(_base5316 + (20+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5354.source.stackId)); + break; + } + case _Tag5395.consume: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionConsume _payload5360 = _elem5316.getConsume(); + *cast(ubyte*)(_base5316 + 0) = cast(ubyte)(5); + *cast(ubyte*)(_base5316 + size_t.sizeof) = cast(ubyte)(cast(uint)(_payload5360.count)); + *cast(ubyte*)(_base5316 + (4+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5360.source.containerName.containerName)); + if (_payload5360.source.containerName.dynamicId.isSome) { + ref _payload5364 = _payload5360.source.containerName.dynamicId.unwrap(); + *cast(ubyte*)(_base5316 + (8+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base5316 + (12+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5364)); + } else { + *cast(ubyte*)(_base5316 + (8+1*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base5316 + (16+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5360.source.slotId)); + *cast(uint*)(_base5316 + (20+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5360.source.stackId)); + break; + } + case _Tag5395.create: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionCreate _payload5366 = _elem5316.getCreate(); + *cast(ubyte*)(_base5316 + 0) = cast(ubyte)(6); + *cast(ubyte*)(_base5316 + size_t.sizeof) = cast(ubyte)(cast(uint)(_payload5366.resultIndex)); + break; + } + case _Tag5395.labTableCombine: { + *cast(ubyte*)(_base5316 + 0) = cast(ubyte)(7); + break; + } + case _Tag5395.beaconPayment: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionBeaconPayment _payload5370 = _elem5316.getBeaconPayment(); + *cast(ubyte*)(_base5316 + 0) = cast(ubyte)(8); + *cast(uint*)(_base5316 + size_t.sizeof) = cast(uint)(cast(uint)(_payload5370.primaryEffectId)); + *cast(uint*)(_base5316 + (4+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5370.secondaryEffectId)); + break; + } + case _Tag5395.mineBlock: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionMineBlock _payload5372 = _elem5316.getMineBlock(); + *cast(ubyte*)(_base5316 + 0) = cast(ubyte)(9); + *cast(uint*)(_base5316 + size_t.sizeof) = cast(uint)(cast(uint)(_payload5372.hotbarSlot)); + *cast(uint*)(_base5316 + (4+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5372.predictedDurability)); + *cast(uint*)(_base5316 + (8+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5372.stackId)); + break; + } + case _Tag5395.craftRecipe: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionCraftRecipe _payload5374 = _elem5316.getCraftRecipe(); + *cast(ubyte*)(_base5316 + 0) = cast(ubyte)(10); + *cast(uint*)(_base5316 + size_t.sizeof) = cast(uint)(cast(uint)(_payload5374.recipeId)); + *cast(ubyte*)(_base5316 + (4+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5374.repetitions)); + break; + } + case _Tag5395.craftRecipeAuto: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionCraftRecipeAuto _payload5376 = _elem5316.getCraftRecipeAuto(); + *cast(ubyte*)(_base5316 + 0) = cast(ubyte)(11); + *cast(uint*)(_base5316 + size_t.sizeof) = cast(uint)(cast(uint)(_payload5376.recipeId)); + *cast(ubyte*)(_base5316 + (4+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5376.repetitions)); + break; + } + case _Tag5395.craftCreative: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionCraftCreative _payload5378 = _elem5316.getCraftCreative(); + *cast(ubyte*)(_base5316 + 0) = cast(ubyte)(12); + *cast(uint*)(_base5316 + size_t.sizeof) = cast(uint)(cast(uint)(_payload5378.creativeItemId)); + *cast(ubyte*)(_base5316 + (4+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5378.repetitions)); + break; + } + case _Tag5395.optional: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionOptional _payload5380 = _elem5316.getOptional(); + *cast(ubyte*)(_base5316 + 0) = cast(ubyte)(13); + *cast(uint*)(_base5316 + size_t.sizeof) = cast(uint)(cast(uint)(_payload5380.recipeId)); + *cast(uint*)(_base5316 + (4+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5380.filterStringIndex)); + break; + } + case _Tag5395.grindstone: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionGrindstone _payload5382 = _elem5316.getGrindstone(); + *cast(ubyte*)(_base5316 + 0) = cast(ubyte)(14); + *cast(uint*)(_base5316 + size_t.sizeof) = cast(uint)(cast(uint)(_payload5382.recipeId)); + *cast(uint*)(_base5316 + (4+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5382.repairCost)); + *cast(ubyte*)(_base5316 + (8+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5382.repetitions)); + break; + } + case _Tag5395.loom: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionLoom _payload5384 = _elem5316.getLoom(); + *cast(ubyte*)(_base5316 + 0) = cast(ubyte)(15); + *cast(size_t*)(_base5316 + (2*size_t.sizeof)) = cast(size_t)(_payload5384.patternId.length); + *cast(void**)(_base5316 + size_t.sizeof) = cast(void*)(cast(void*)(_payload5384.patternId.ptr)); + *cast(ubyte*)(_base5316 + (3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5384.repetitions)); + break; + } + case _Tag5395.craftNonImplemented: { + *cast(ubyte*)(_base5316 + 0) = cast(ubyte)(16); + break; + } + case _Tag5395.craftResultsDeprecated: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionCraftResultsDeprecated _payload5388 = _elem5316.getCraftResultsDeprecated(); + *cast(ubyte*)(_base5316 + 0) = cast(ubyte)(17); + auto _listSrc5394 = _payload5388.resultItems; + auto _list5394 = _listSrc5394.length ? wit.common.malloc(_listSrc5394.length * ((8+6*size_t.sizeof))) : null; + assert(!_listSrc5394.length || _list5394); + foreach (_elem5389_idx, ref _elem5389; _listSrc5394) { + auto _base5389 = _list5394 + _elem5389_idx * ((8+6*size_t.sizeof)); + if (_elem5389.identifier.isSome) { + ref _payload5393 = _elem5389.identifier.unwrap(); + *cast(ubyte*)(_base5389 + 0) = cast(ubyte)(1); + *cast(size_t*)(_base5389 + (2*size_t.sizeof)) = cast(size_t)(_payload5393.length); + *cast(void**)(_base5389 + size_t.sizeof) = cast(void*)(cast(void*)(_payload5393.ptr)); + } else { + *cast(ubyte*)(_base5389 + 0) = cast(ubyte)(0); + } + *cast(uint*)(_base5389 + (3*size_t.sizeof)) = cast(uint)(cast(uint)(_elem5389.metadataValue)); + *cast(uint*)(_base5389 + (4+3*size_t.sizeof)) = cast(uint)(cast(uint)(_elem5389.count)); + *cast(uint*)(_base5389 + (8+3*size_t.sizeof)) = cast(uint)(cast(uint)(_elem5389.blockRuntimeId)); + *cast(size_t*)(_base5389 + (8+5*size_t.sizeof)) = cast(size_t)(_elem5389.extraData.length); + *cast(void**)(_base5389 + (8+4*size_t.sizeof)) = cast(void*)(cast(void*)(_elem5389.extraData.ptr)); + + } + if (_listSrc5394.length) wit.common.free(_listSrc5394.ptr); + *cast(size_t*)(_base5316 + (2*size_t.sizeof)) = cast(size_t)(_payload5388.resultItems.length); + *cast(void**)(_base5316 + size_t.sizeof) = cast(void*)(_list5394); + *cast(ubyte*)(_base5316 + (3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5388.timesCrafted)); + break; + } + } + + } + if (_listSrc5396.length) wit.common.free(_listSrc5396.ptr); + *cast(size_t*)(_base5315 + (2*size_t.sizeof)) = cast(size_t)(_elem5315.actions.length); + *cast(void**)(_base5315 + size_t.sizeof) = cast(void*)(_list5396); + auto _listSrc5398 = _elem5315.filterStrings; + auto _list5398 = _listSrc5398.length ? wit.common.malloc(_listSrc5398.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5398.length || _list5398); + foreach (_elem5397_idx, ref _elem5397; _listSrc5398) { + auto _base5397 = _list5398 + _elem5397_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5397 + size_t.sizeof) = cast(size_t)(_elem5397.length); + *cast(void**)(_base5397 + 0) = cast(void*)(cast(void*)(_elem5397.ptr)); + + } + if (_listSrc5398.length) wit.common.free(_listSrc5398.ptr); + *cast(size_t*)(_base5315 + (4*size_t.sizeof)) = cast(size_t)(_elem5315.filterStrings.length); + *cast(void**)(_base5315 + (3*size_t.sizeof)) = cast(void*)(_list5398); + *cast(uint*)(_base5315 + (5*size_t.sizeof)) = cast(uint)(cast(uint)(_elem5315.filterCause)); + + } + if (_listSrc5399.length) wit.common.free(_listSrc5399.ptr); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5314.requests.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(_list5399); + break; + } + case _Tag5590.sLoadingScreen: { + ref wit.pumpkin.plugin.bedrock_packets.common.SLoadingScreen _payload5401 = _payload5235.getSLoadingScreen(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(12); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload5401.loadingScreenPacketType)); + if (_payload5401.loadingScreenId.isSome) { + ref _payload5405 = _payload5401.loadingScreenId.unwrap(); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5405)); + } else { + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(0); + } + break; + } + case _Tag5590.sLogin: { + ref wit.pumpkin.plugin.bedrock_packets.common.SLogin _payload5407 = _payload5235.getSLogin(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(13); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5407.protocolVersion)); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload5407.jwt.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5407.jwt.ptr)); + *cast(size_t*)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(size_t)(_payload5407.rawToken.length); + *cast(void**)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5407.rawToken.ptr)); + break; + } + case _Tag5590.sMobEquipment: { + ref wit.pumpkin.plugin.bedrock_packets.common.SMobEquipment _payload5409 = _payload5235.getSMobEquipment(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(14); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload5409.entityRuntimeId)); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5409.item.id)); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload5409.item.stackSize)); + *cast(uint*)(_retArea.ptr + 48) = cast(uint)(cast(uint)(_payload5409.item.auxValue)); + *cast(uint*)(_retArea.ptr + 52) = cast(uint)(cast(uint)(_payload5409.item.blockRuntimeId)); + *cast(size_t*)(_retArea.ptr + (56+1*size_t.sizeof)) = cast(size_t)(_payload5409.item.extraData.length); + *cast(void**)(_retArea.ptr + 56) = cast(void*)(cast(void*)(_payload5409.item.extraData.ptr)); + if (_payload5409.item.netId.isSome) { + ref _payload5413 = _payload5409.item.netId.unwrap(); + *cast(ubyte*)(_retArea.ptr + (56+2*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (60+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5413)); + } else { + *cast(ubyte*)(_retArea.ptr + (56+2*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + (64+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5409.slot)); + *cast(ubyte*)(_retArea.ptr + (65+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5409.selectedSlot)); + *cast(ubyte*)(_retArea.ptr + (66+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5409.containerId)); + break; + } + case _Tag5590.sModalFormResponse: { + ref wit.pumpkin.plugin.bedrock_packets.common.SModalFormResponse _payload5415 = _payload5235.getSModalFormResponse(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(15); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5415.formId)); + if (_payload5415.jsonResponse.isSome) { + ref _payload5419 = _payload5415.jsonResponse.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(size_t)(_payload5419.length); + *cast(void**)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5419.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(ubyte)(0); + } + if (_payload5415.formCancelReason.isSome) { + ref _payload5423 = _payload5415.formCancelReason.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(ubyte*)(_retArea.ptr + (33+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5423)); + } else { + *cast(ubyte*)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag5590.sPacketViolationWarning: { + ref wit.pumpkin.plugin.bedrock_packets.common.SPacketViolationWarning _payload5425 = _payload5235.getSPacketViolationWarning(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(16); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5425.violationType)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5425.violationSeverity)); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5425.violationPacketId)); + *cast(size_t*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(size_t)(_payload5425.violationContext.length); + *cast(void**)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5425.violationContext.ptr)); + break; + } + case _Tag5590.sPlayerAction: { + ref wit.pumpkin.plugin.bedrock_packets.common.SPlayerAction _payload5427 = _payload5235.getSPlayerAction(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(17); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload5427.playerRuntimeId)); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(cast(uint)(_payload5427.action)); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload5427.blockPosition[0])); + *cast(uint*)(_retArea.ptr + 48) = cast(uint)(cast(uint)(_payload5427.blockPosition[1])); + *cast(uint*)(_retArea.ptr + 52) = cast(uint)(cast(uint)(_payload5427.blockPosition[2])); + *cast(uint*)(_retArea.ptr + 56) = cast(uint)(cast(uint)(_payload5427.resultPos[0])); + *cast(uint*)(_retArea.ptr + 60) = cast(uint)(cast(uint)(_payload5427.resultPos[1])); + *cast(uint*)(_retArea.ptr + 64) = cast(uint)(cast(uint)(_payload5427.resultPos[2])); + *cast(uint*)(_retArea.ptr + 68) = cast(uint)(cast(uint)(_payload5427.face)); + break; + } + case _Tag5590.sPlayerAuthInput: { + ref wit.pumpkin.plugin.bedrock_packets.common.SPlayerAuthInput _payload5429 = _payload5235.getSPlayerAuthInput(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(18); + *cast(float*)(_retArea.ptr + 32) = cast(float)(_payload5429.pitch); + *cast(float*)(_retArea.ptr + 36) = cast(float)(_payload5429.yaw); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload5429.position[0]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload5429.position[1]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload5429.position[2]); + *cast(double*)(_retArea.ptr + 64) = cast(double)(_payload5429.moveVec[0]); + *cast(double*)(_retArea.ptr + 72) = cast(double)(_payload5429.moveVec[1]); + *cast(float*)(_retArea.ptr + 80) = cast(float)(_payload5429.headYaw); + *cast(size_t*)(_retArea.ptr + (80+2*size_t.sizeof)) = cast(size_t)(_payload5429.inputData.length); + *cast(void**)(_retArea.ptr + (80+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5429.inputData.ptr)); + *cast(uint*)(_retArea.ptr + (80+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5429.inputMode)); + *cast(uint*)(_retArea.ptr + (84+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5429.playMode)); + *cast(uint*)(_retArea.ptr + (88+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5429.interactionModel)); + *cast(float*)(_retArea.ptr + (92+3*size_t.sizeof)) = cast(float)(_payload5429.interactPitch); + *cast(float*)(_retArea.ptr + (96+3*size_t.sizeof)) = cast(float)(_payload5429.interactYaw); + *cast(ulong*)(_retArea.ptr + (96+4*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload5429.tick)); + *cast(double*)(_retArea.ptr + (104+4*size_t.sizeof)) = cast(double)(_payload5429.delta[0]); + *cast(double*)(_retArea.ptr + (112+4*size_t.sizeof)) = cast(double)(_payload5429.delta[1]); + *cast(double*)(_retArea.ptr + (120+4*size_t.sizeof)) = cast(double)(_payload5429.delta[2]); + if (_payload5429.blockActions.isSome) { + ref _payload5433 = _payload5429.blockActions.unwrap(); + *cast(ubyte*)(_retArea.ptr + (128+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (128+6*size_t.sizeof)) = cast(size_t)(_payload5433.length); + *cast(void**)(_retArea.ptr + (128+5*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5433.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (128+4*size_t.sizeof)) = cast(ubyte)(0); + } + if (_payload5429.itemInteraction.isSome) { + ref _payload5437 = _payload5429.itemInteraction.unwrap(); + *cast(ubyte*)(_retArea.ptr + (136+6*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (144+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5437.legacyRequestId)); + auto _listSrc5439 = _payload5437.legacySlots; + auto _list5439 = _listSrc5439.length ? wit.common.malloc(_listSrc5439.length * ((3*size_t.sizeof))) : null; + assert(!_listSrc5439.length || _list5439); + foreach (_elem5438_idx, ref _elem5438; _listSrc5439) { + auto _base5438 = _list5439 + _elem5438_idx * ((3*size_t.sizeof)); + *cast(ubyte*)(_base5438 + 0) = cast(ubyte)(cast(uint)(_elem5438.containerId)); + *cast(size_t*)(_base5438 + (2*size_t.sizeof)) = cast(size_t)(_elem5438.slots.length); + *cast(void**)(_base5438 + size_t.sizeof) = cast(void*)(cast(void*)(_elem5438.slots.ptr)); + + } + if (_listSrc5439.length) wit.common.free(_listSrc5439.ptr); + *cast(size_t*)(_retArea.ptr + (144+8*size_t.sizeof)) = cast(size_t)(_payload5437.legacySlots.length); + *cast(void**)(_retArea.ptr + (144+7*size_t.sizeof)) = cast(void*)(_list5439); + auto _listSrc5457 = _payload5437.actions; + auto _list5457 = _listSrc5457.length ? wit.common.malloc(_listSrc5457.length * ((72+12*size_t.sizeof))) : null; + assert(!_listSrc5457.length || _list5457); + foreach (_elem5440_idx, ref _elem5440; _listSrc5457) { + auto _base5440 = _list5457 + _elem5440_idx * ((72+12*size_t.sizeof)); + *cast(uint*)(_base5440 + 0) = cast(uint)(cast(uint)(_elem5440.sourceType)); + if (_elem5440.windowId.isSome) { + ref _payload5444 = _elem5440.windowId.unwrap(); + *cast(ubyte*)(_base5440 + 4) = cast(ubyte)(1); + *cast(uint*)(_base5440 + 8) = cast(uint)(cast(uint)(_payload5444)); + } else { + *cast(ubyte*)(_base5440 + 4) = cast(ubyte)(0); + } + if (_elem5440.sourceFlags.isSome) { + ref _payload5448 = _elem5440.sourceFlags.unwrap(); + *cast(ubyte*)(_base5440 + 12) = cast(ubyte)(1); + *cast(uint*)(_base5440 + 16) = cast(uint)(cast(uint)(_payload5448)); + } else { + *cast(ubyte*)(_base5440 + 12) = cast(ubyte)(0); + } + *cast(uint*)(_base5440 + 20) = cast(uint)(cast(uint)(_elem5440.inventorySlot)); + *cast(uint*)(_base5440 + 24) = cast(uint)(cast(uint)(_elem5440.oldItem.id)); + *cast(uint*)(_base5440 + 28) = cast(uint)(cast(uint)(_elem5440.oldItem.stackSize)); + *cast(uint*)(_base5440 + 32) = cast(uint)(cast(uint)(_elem5440.oldItem.auxValue)); + *cast(uint*)(_base5440 + 36) = cast(uint)(cast(uint)(_elem5440.oldItem.blockRuntimeId)); + *cast(size_t*)(_base5440 + (40+1*size_t.sizeof)) = cast(size_t)(_elem5440.oldItem.nbtData.length); + *cast(void**)(_base5440 + 40) = cast(void*)(cast(void*)(_elem5440.oldItem.nbtData.ptr)); + auto _listSrc5450 = _elem5440.oldItem.placeOnBlocks; + auto _list5450 = _listSrc5450.length ? wit.common.malloc(_listSrc5450.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5450.length || _list5450); + foreach (_elem5449_idx, ref _elem5449; _listSrc5450) { + auto _base5449 = _list5450 + _elem5449_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5449 + size_t.sizeof) = cast(size_t)(_elem5449.length); + *cast(void**)(_base5449 + 0) = cast(void*)(cast(void*)(_elem5449.ptr)); + + } + if (_listSrc5450.length) wit.common.free(_listSrc5450.ptr); + *cast(size_t*)(_base5440 + (40+3*size_t.sizeof)) = cast(size_t)(_elem5440.oldItem.placeOnBlocks.length); + *cast(void**)(_base5440 + (40+2*size_t.sizeof)) = cast(void*)(_list5450); + auto _listSrc5452 = _elem5440.oldItem.destroyBlocks; + auto _list5452 = _listSrc5452.length ? wit.common.malloc(_listSrc5452.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5452.length || _list5452); + foreach (_elem5451_idx, ref _elem5451; _listSrc5452) { + auto _base5451 = _list5452 + _elem5451_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5451 + size_t.sizeof) = cast(size_t)(_elem5451.length); + *cast(void**)(_base5451 + 0) = cast(void*)(cast(void*)(_elem5451.ptr)); + + } + if (_listSrc5452.length) wit.common.free(_listSrc5452.ptr); + *cast(size_t*)(_base5440 + (40+5*size_t.sizeof)) = cast(size_t)(_elem5440.oldItem.destroyBlocks.length); + *cast(void**)(_base5440 + (40+4*size_t.sizeof)) = cast(void*)(_list5452); + *cast(ulong*)(_base5440 + (40+6*size_t.sizeof)) = cast(ulong)(cast(ulong)(_elem5440.oldItem.shieldBlockingTick)); + *cast(uint*)(_base5440 + (48+6*size_t.sizeof)) = cast(uint)(cast(uint)(_elem5440.newItem.id)); + *cast(uint*)(_base5440 + (52+6*size_t.sizeof)) = cast(uint)(cast(uint)(_elem5440.newItem.stackSize)); + *cast(uint*)(_base5440 + (56+6*size_t.sizeof)) = cast(uint)(cast(uint)(_elem5440.newItem.auxValue)); + *cast(uint*)(_base5440 + (60+6*size_t.sizeof)) = cast(uint)(cast(uint)(_elem5440.newItem.blockRuntimeId)); + *cast(size_t*)(_base5440 + (64+7*size_t.sizeof)) = cast(size_t)(_elem5440.newItem.nbtData.length); + *cast(void**)(_base5440 + (64+6*size_t.sizeof)) = cast(void*)(cast(void*)(_elem5440.newItem.nbtData.ptr)); + auto _listSrc5454 = _elem5440.newItem.placeOnBlocks; + auto _list5454 = _listSrc5454.length ? wit.common.malloc(_listSrc5454.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5454.length || _list5454); + foreach (_elem5453_idx, ref _elem5453; _listSrc5454) { + auto _base5453 = _list5454 + _elem5453_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5453 + size_t.sizeof) = cast(size_t)(_elem5453.length); + *cast(void**)(_base5453 + 0) = cast(void*)(cast(void*)(_elem5453.ptr)); + + } + if (_listSrc5454.length) wit.common.free(_listSrc5454.ptr); + *cast(size_t*)(_base5440 + (64+9*size_t.sizeof)) = cast(size_t)(_elem5440.newItem.placeOnBlocks.length); + *cast(void**)(_base5440 + (64+8*size_t.sizeof)) = cast(void*)(_list5454); + auto _listSrc5456 = _elem5440.newItem.destroyBlocks; + auto _list5456 = _listSrc5456.length ? wit.common.malloc(_listSrc5456.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5456.length || _list5456); + foreach (_elem5455_idx, ref _elem5455; _listSrc5456) { + auto _base5455 = _list5456 + _elem5455_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5455 + size_t.sizeof) = cast(size_t)(_elem5455.length); + *cast(void**)(_base5455 + 0) = cast(void*)(cast(void*)(_elem5455.ptr)); + + } + if (_listSrc5456.length) wit.common.free(_listSrc5456.ptr); + *cast(size_t*)(_base5440 + (64+11*size_t.sizeof)) = cast(size_t)(_elem5440.newItem.destroyBlocks.length); + *cast(void**)(_base5440 + (64+10*size_t.sizeof)) = cast(void*)(_list5456); + *cast(ulong*)(_base5440 + (64+12*size_t.sizeof)) = cast(ulong)(cast(ulong)(_elem5440.newItem.shieldBlockingTick)); + + } + if (_listSrc5457.length) wit.common.free(_listSrc5457.ptr); + *cast(size_t*)(_retArea.ptr + (144+10*size_t.sizeof)) = cast(size_t)(_payload5437.actions.length); + *cast(void**)(_retArea.ptr + (144+9*size_t.sizeof)) = cast(void*)(_list5457); + *cast(uint*)(_retArea.ptr + (152+10*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5437.transaction.actionType)); + *cast(ubyte*)(_retArea.ptr + (156+10*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5437.transaction.triggerType)); + *cast(uint*)(_retArea.ptr + (160+10*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5437.transaction.blockPosition[0])); + *cast(uint*)(_retArea.ptr + (164+10*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5437.transaction.blockPosition[1])); + *cast(uint*)(_retArea.ptr + (168+10*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5437.transaction.blockPosition[2])); + *cast(ubyte*)(_retArea.ptr + (172+10*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5437.transaction.blockFace)); + *cast(uint*)(_retArea.ptr + (176+10*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5437.transaction.hotBarSlot)); + *cast(uint*)(_retArea.ptr + (184+10*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5437.transaction.itemInHand.id)); + *cast(uint*)(_retArea.ptr + (188+10*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5437.transaction.itemInHand.stackSize)); + *cast(uint*)(_retArea.ptr + (192+10*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5437.transaction.itemInHand.auxValue)); + *cast(uint*)(_retArea.ptr + (196+10*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5437.transaction.itemInHand.blockRuntimeId)); + *cast(size_t*)(_retArea.ptr + (200+11*size_t.sizeof)) = cast(size_t)(_payload5437.transaction.itemInHand.nbtData.length); + *cast(void**)(_retArea.ptr + (200+10*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5437.transaction.itemInHand.nbtData.ptr)); + auto _listSrc5459 = _payload5437.transaction.itemInHand.placeOnBlocks; + auto _list5459 = _listSrc5459.length ? wit.common.malloc(_listSrc5459.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5459.length || _list5459); + foreach (_elem5458_idx, ref _elem5458; _listSrc5459) { + auto _base5458 = _list5459 + _elem5458_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5458 + size_t.sizeof) = cast(size_t)(_elem5458.length); + *cast(void**)(_base5458 + 0) = cast(void*)(cast(void*)(_elem5458.ptr)); + + } + if (_listSrc5459.length) wit.common.free(_listSrc5459.ptr); + *cast(size_t*)(_retArea.ptr + (200+13*size_t.sizeof)) = cast(size_t)(_payload5437.transaction.itemInHand.placeOnBlocks.length); + *cast(void**)(_retArea.ptr + (200+12*size_t.sizeof)) = cast(void*)(_list5459); + auto _listSrc5461 = _payload5437.transaction.itemInHand.destroyBlocks; + auto _list5461 = _listSrc5461.length ? wit.common.malloc(_listSrc5461.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5461.length || _list5461); + foreach (_elem5460_idx, ref _elem5460; _listSrc5461) { + auto _base5460 = _list5461 + _elem5460_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5460 + size_t.sizeof) = cast(size_t)(_elem5460.length); + *cast(void**)(_base5460 + 0) = cast(void*)(cast(void*)(_elem5460.ptr)); + + } + if (_listSrc5461.length) wit.common.free(_listSrc5461.ptr); + *cast(size_t*)(_retArea.ptr + (200+15*size_t.sizeof)) = cast(size_t)(_payload5437.transaction.itemInHand.destroyBlocks.length); + *cast(void**)(_retArea.ptr + (200+14*size_t.sizeof)) = cast(void*)(_list5461); + *cast(ulong*)(_retArea.ptr + (200+16*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload5437.transaction.itemInHand.shieldBlockingTick)); + *cast(double*)(_retArea.ptr + (208+16*size_t.sizeof)) = cast(double)(_payload5437.transaction.playerPosition[0]); + *cast(double*)(_retArea.ptr + (216+16*size_t.sizeof)) = cast(double)(_payload5437.transaction.playerPosition[1]); + *cast(double*)(_retArea.ptr + (224+16*size_t.sizeof)) = cast(double)(_payload5437.transaction.playerPosition[2]); + *cast(double*)(_retArea.ptr + (232+16*size_t.sizeof)) = cast(double)(_payload5437.transaction.clickPosition[0]); + *cast(double*)(_retArea.ptr + (240+16*size_t.sizeof)) = cast(double)(_payload5437.transaction.clickPosition[1]); + *cast(double*)(_retArea.ptr + (248+16*size_t.sizeof)) = cast(double)(_payload5437.transaction.clickPosition[2]); + *cast(uint*)(_retArea.ptr + (256+16*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5437.transaction.blockRuntimeId)); + *cast(ubyte*)(_retArea.ptr + (260+16*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5437.transaction.clientPrediction)); + *cast(ubyte*)(_retArea.ptr + (261+16*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5437.transaction.clientCooldownState)); + } else { + *cast(ubyte*)(_retArea.ptr + (136+6*size_t.sizeof)) = cast(ubyte)(0); + } + if (_payload5429.itemStackRequest.isSome) { + ref _payload5465 = _payload5429.itemStackRequest.unwrap(); + *cast(ubyte*)(_retArea.ptr + (264+16*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (264+17*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5465.requestId)); + auto _listSrc5546 = _payload5465.actions; + auto _list5546 = _listSrc5546.length ? wit.common.malloc(_listSrc5546.length * ((40+2*size_t.sizeof))) : null; + assert(!_listSrc5546.length || _list5546); + foreach (_elem5466_idx, ref _elem5466; _listSrc5546) { + auto _base5466 = _list5546 + _elem5466_idx * ((40+2*size_t.sizeof)); + alias _Tag5545 = wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestAction.Tag; + final switch (_elem5466.tag) { + case _Tag5545.take: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionTake _payload5468 = _elem5466.getTake(); + *cast(ubyte*)(_base5466 + 0) = cast(ubyte)(0); + *cast(ubyte*)(_base5466 + size_t.sizeof) = cast(ubyte)(cast(uint)(_payload5468.count)); + *cast(ubyte*)(_base5466 + (4+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5468.source.containerName.containerName)); + if (_payload5468.source.containerName.dynamicId.isSome) { + ref _payload5472 = _payload5468.source.containerName.dynamicId.unwrap(); + *cast(ubyte*)(_base5466 + (8+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base5466 + (12+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5472)); + } else { + *cast(ubyte*)(_base5466 + (8+1*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base5466 + (16+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5468.source.slotId)); + *cast(uint*)(_base5466 + (20+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5468.source.stackId)); + *cast(ubyte*)(_base5466 + (24+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5468.destination.containerName.containerName)); + if (_payload5468.destination.containerName.dynamicId.isSome) { + ref _payload5476 = _payload5468.destination.containerName.dynamicId.unwrap(); + *cast(ubyte*)(_base5466 + (28+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base5466 + (32+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5476)); + } else { + *cast(ubyte*)(_base5466 + (28+1*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base5466 + (36+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5468.destination.slotId)); + *cast(uint*)(_base5466 + (40+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5468.destination.stackId)); + break; + } + case _Tag5545.place: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionPlace _payload5478 = _elem5466.getPlace(); + *cast(ubyte*)(_base5466 + 0) = cast(ubyte)(1); + *cast(ubyte*)(_base5466 + size_t.sizeof) = cast(ubyte)(cast(uint)(_payload5478.count)); + *cast(ubyte*)(_base5466 + (4+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5478.source.containerName.containerName)); + if (_payload5478.source.containerName.dynamicId.isSome) { + ref _payload5482 = _payload5478.source.containerName.dynamicId.unwrap(); + *cast(ubyte*)(_base5466 + (8+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base5466 + (12+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5482)); + } else { + *cast(ubyte*)(_base5466 + (8+1*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base5466 + (16+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5478.source.slotId)); + *cast(uint*)(_base5466 + (20+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5478.source.stackId)); + *cast(ubyte*)(_base5466 + (24+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5478.destination.containerName.containerName)); + if (_payload5478.destination.containerName.dynamicId.isSome) { + ref _payload5486 = _payload5478.destination.containerName.dynamicId.unwrap(); + *cast(ubyte*)(_base5466 + (28+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base5466 + (32+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5486)); + } else { + *cast(ubyte*)(_base5466 + (28+1*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base5466 + (36+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5478.destination.slotId)); + *cast(uint*)(_base5466 + (40+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5478.destination.stackId)); + break; + } + case _Tag5545.swap: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionSwap _payload5488 = _elem5466.getSwap(); + *cast(ubyte*)(_base5466 + 0) = cast(ubyte)(2); + *cast(ubyte*)(_base5466 + size_t.sizeof) = cast(ubyte)(cast(uint)(_payload5488.slot1.containerName.containerName)); + if (_payload5488.slot1.containerName.dynamicId.isSome) { + ref _payload5492 = _payload5488.slot1.containerName.dynamicId.unwrap(); + *cast(ubyte*)(_base5466 + (4+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base5466 + (8+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5492)); + } else { + *cast(ubyte*)(_base5466 + (4+1*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base5466 + (12+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5488.slot1.slotId)); + *cast(uint*)(_base5466 + (16+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5488.slot1.stackId)); + *cast(ubyte*)(_base5466 + (20+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5488.slot2.containerName.containerName)); + if (_payload5488.slot2.containerName.dynamicId.isSome) { + ref _payload5496 = _payload5488.slot2.containerName.dynamicId.unwrap(); + *cast(ubyte*)(_base5466 + (24+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base5466 + (28+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5496)); + } else { + *cast(ubyte*)(_base5466 + (24+1*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base5466 + (32+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5488.slot2.slotId)); + *cast(uint*)(_base5466 + (36+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5488.slot2.stackId)); + break; + } + case _Tag5545.drop: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionDrop _payload5498 = _elem5466.getDrop(); + *cast(ubyte*)(_base5466 + 0) = cast(ubyte)(3); + *cast(ubyte*)(_base5466 + size_t.sizeof) = cast(ubyte)(cast(uint)(_payload5498.count)); + *cast(ubyte*)(_base5466 + (4+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5498.source.containerName.containerName)); + if (_payload5498.source.containerName.dynamicId.isSome) { + ref _payload5502 = _payload5498.source.containerName.dynamicId.unwrap(); + *cast(ubyte*)(_base5466 + (8+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base5466 + (12+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5502)); + } else { + *cast(ubyte*)(_base5466 + (8+1*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base5466 + (16+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5498.source.slotId)); + *cast(uint*)(_base5466 + (20+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5498.source.stackId)); + *cast(ubyte*)(_base5466 + (24+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5498.randomly)); + break; + } + case _Tag5545.destroy: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionDestroy _payload5504 = _elem5466.getDestroy(); + *cast(ubyte*)(_base5466 + 0) = cast(ubyte)(4); + *cast(ubyte*)(_base5466 + size_t.sizeof) = cast(ubyte)(cast(uint)(_payload5504.count)); + *cast(ubyte*)(_base5466 + (4+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5504.source.containerName.containerName)); + if (_payload5504.source.containerName.dynamicId.isSome) { + ref _payload5508 = _payload5504.source.containerName.dynamicId.unwrap(); + *cast(ubyte*)(_base5466 + (8+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base5466 + (12+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5508)); + } else { + *cast(ubyte*)(_base5466 + (8+1*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base5466 + (16+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5504.source.slotId)); + *cast(uint*)(_base5466 + (20+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5504.source.stackId)); + break; + } + case _Tag5545.consume: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionConsume _payload5510 = _elem5466.getConsume(); + *cast(ubyte*)(_base5466 + 0) = cast(ubyte)(5); + *cast(ubyte*)(_base5466 + size_t.sizeof) = cast(ubyte)(cast(uint)(_payload5510.count)); + *cast(ubyte*)(_base5466 + (4+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5510.source.containerName.containerName)); + if (_payload5510.source.containerName.dynamicId.isSome) { + ref _payload5514 = _payload5510.source.containerName.dynamicId.unwrap(); + *cast(ubyte*)(_base5466 + (8+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base5466 + (12+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5514)); + } else { + *cast(ubyte*)(_base5466 + (8+1*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base5466 + (16+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5510.source.slotId)); + *cast(uint*)(_base5466 + (20+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5510.source.stackId)); + break; + } + case _Tag5545.create: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionCreate _payload5516 = _elem5466.getCreate(); + *cast(ubyte*)(_base5466 + 0) = cast(ubyte)(6); + *cast(ubyte*)(_base5466 + size_t.sizeof) = cast(ubyte)(cast(uint)(_payload5516.resultIndex)); + break; + } + case _Tag5545.labTableCombine: { + *cast(ubyte*)(_base5466 + 0) = cast(ubyte)(7); + break; + } + case _Tag5545.beaconPayment: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionBeaconPayment _payload5520 = _elem5466.getBeaconPayment(); + *cast(ubyte*)(_base5466 + 0) = cast(ubyte)(8); + *cast(uint*)(_base5466 + size_t.sizeof) = cast(uint)(cast(uint)(_payload5520.primaryEffectId)); + *cast(uint*)(_base5466 + (4+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5520.secondaryEffectId)); + break; + } + case _Tag5545.mineBlock: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionMineBlock _payload5522 = _elem5466.getMineBlock(); + *cast(ubyte*)(_base5466 + 0) = cast(ubyte)(9); + *cast(uint*)(_base5466 + size_t.sizeof) = cast(uint)(cast(uint)(_payload5522.hotbarSlot)); + *cast(uint*)(_base5466 + (4+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5522.predictedDurability)); + *cast(uint*)(_base5466 + (8+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5522.stackId)); + break; + } + case _Tag5545.craftRecipe: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionCraftRecipe _payload5524 = _elem5466.getCraftRecipe(); + *cast(ubyte*)(_base5466 + 0) = cast(ubyte)(10); + *cast(uint*)(_base5466 + size_t.sizeof) = cast(uint)(cast(uint)(_payload5524.recipeId)); + *cast(ubyte*)(_base5466 + (4+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5524.repetitions)); + break; + } + case _Tag5545.craftRecipeAuto: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionCraftRecipeAuto _payload5526 = _elem5466.getCraftRecipeAuto(); + *cast(ubyte*)(_base5466 + 0) = cast(ubyte)(11); + *cast(uint*)(_base5466 + size_t.sizeof) = cast(uint)(cast(uint)(_payload5526.recipeId)); + *cast(ubyte*)(_base5466 + (4+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5526.repetitions)); + break; + } + case _Tag5545.craftCreative: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionCraftCreative _payload5528 = _elem5466.getCraftCreative(); + *cast(ubyte*)(_base5466 + 0) = cast(ubyte)(12); + *cast(uint*)(_base5466 + size_t.sizeof) = cast(uint)(cast(uint)(_payload5528.creativeItemId)); + *cast(ubyte*)(_base5466 + (4+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5528.repetitions)); + break; + } + case _Tag5545.optional: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionOptional _payload5530 = _elem5466.getOptional(); + *cast(ubyte*)(_base5466 + 0) = cast(ubyte)(13); + *cast(uint*)(_base5466 + size_t.sizeof) = cast(uint)(cast(uint)(_payload5530.recipeId)); + *cast(uint*)(_base5466 + (4+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5530.filterStringIndex)); + break; + } + case _Tag5545.grindstone: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionGrindstone _payload5532 = _elem5466.getGrindstone(); + *cast(ubyte*)(_base5466 + 0) = cast(ubyte)(14); + *cast(uint*)(_base5466 + size_t.sizeof) = cast(uint)(cast(uint)(_payload5532.recipeId)); + *cast(uint*)(_base5466 + (4+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5532.repairCost)); + *cast(ubyte*)(_base5466 + (8+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5532.repetitions)); + break; + } + case _Tag5545.loom: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionLoom _payload5534 = _elem5466.getLoom(); + *cast(ubyte*)(_base5466 + 0) = cast(ubyte)(15); + *cast(size_t*)(_base5466 + (2*size_t.sizeof)) = cast(size_t)(_payload5534.patternId.length); + *cast(void**)(_base5466 + size_t.sizeof) = cast(void*)(cast(void*)(_payload5534.patternId.ptr)); + *cast(ubyte*)(_base5466 + (3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5534.repetitions)); + break; + } + case _Tag5545.craftNonImplemented: { + *cast(ubyte*)(_base5466 + 0) = cast(ubyte)(16); + break; + } + case _Tag5545.craftResultsDeprecated: { + ref wit.pumpkin.plugin.bedrock_packets.common.ItemStackRequestActionCraftResultsDeprecated _payload5538 = _elem5466.getCraftResultsDeprecated(); + *cast(ubyte*)(_base5466 + 0) = cast(ubyte)(17); + auto _listSrc5544 = _payload5538.resultItems; + auto _list5544 = _listSrc5544.length ? wit.common.malloc(_listSrc5544.length * ((8+6*size_t.sizeof))) : null; + assert(!_listSrc5544.length || _list5544); + foreach (_elem5539_idx, ref _elem5539; _listSrc5544) { + auto _base5539 = _list5544 + _elem5539_idx * ((8+6*size_t.sizeof)); + if (_elem5539.identifier.isSome) { + ref _payload5543 = _elem5539.identifier.unwrap(); + *cast(ubyte*)(_base5539 + 0) = cast(ubyte)(1); + *cast(size_t*)(_base5539 + (2*size_t.sizeof)) = cast(size_t)(_payload5543.length); + *cast(void**)(_base5539 + size_t.sizeof) = cast(void*)(cast(void*)(_payload5543.ptr)); + } else { + *cast(ubyte*)(_base5539 + 0) = cast(ubyte)(0); + } + *cast(uint*)(_base5539 + (3*size_t.sizeof)) = cast(uint)(cast(uint)(_elem5539.metadataValue)); + *cast(uint*)(_base5539 + (4+3*size_t.sizeof)) = cast(uint)(cast(uint)(_elem5539.count)); + *cast(uint*)(_base5539 + (8+3*size_t.sizeof)) = cast(uint)(cast(uint)(_elem5539.blockRuntimeId)); + *cast(size_t*)(_base5539 + (8+5*size_t.sizeof)) = cast(size_t)(_elem5539.extraData.length); + *cast(void**)(_base5539 + (8+4*size_t.sizeof)) = cast(void*)(cast(void*)(_elem5539.extraData.ptr)); + + } + if (_listSrc5544.length) wit.common.free(_listSrc5544.ptr); + *cast(size_t*)(_base5466 + (2*size_t.sizeof)) = cast(size_t)(_payload5538.resultItems.length); + *cast(void**)(_base5466 + size_t.sizeof) = cast(void*)(_list5544); + *cast(ubyte*)(_base5466 + (3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5538.timesCrafted)); + break; + } + } + + } + if (_listSrc5546.length) wit.common.free(_listSrc5546.ptr); + *cast(size_t*)(_retArea.ptr + (264+19*size_t.sizeof)) = cast(size_t)(_payload5465.actions.length); + *cast(void**)(_retArea.ptr + (264+18*size_t.sizeof)) = cast(void*)(_list5546); + auto _listSrc5548 = _payload5465.filterStrings; + auto _list5548 = _listSrc5548.length ? wit.common.malloc(_listSrc5548.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5548.length || _list5548); + foreach (_elem5547_idx, ref _elem5547; _listSrc5548) { + auto _base5547 = _list5548 + _elem5547_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5547 + size_t.sizeof) = cast(size_t)(_elem5547.length); + *cast(void**)(_base5547 + 0) = cast(void*)(cast(void*)(_elem5547.ptr)); + + } + if (_listSrc5548.length) wit.common.free(_listSrc5548.ptr); + *cast(size_t*)(_retArea.ptr + (264+21*size_t.sizeof)) = cast(size_t)(_payload5465.filterStrings.length); + *cast(void**)(_retArea.ptr + (264+20*size_t.sizeof)) = cast(void*)(_list5548); + *cast(uint*)(_retArea.ptr + (264+22*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5465.filterCause)); + } else { + *cast(ubyte*)(_retArea.ptr + (264+16*size_t.sizeof)) = cast(ubyte)(0); + } + if (_payload5429.vehicleRotation.isSome) { + ref _payload5552 = _payload5429.vehicleRotation.unwrap(); + *cast(ubyte*)(_retArea.ptr + (272+22*size_t.sizeof)) = cast(ubyte)(1); + *cast(double*)(_retArea.ptr + (280+22*size_t.sizeof)) = cast(double)(_payload5552[0]); + *cast(double*)(_retArea.ptr + (288+22*size_t.sizeof)) = cast(double)(_payload5552[1]); + } else { + *cast(ubyte*)(_retArea.ptr + (272+22*size_t.sizeof)) = cast(ubyte)(0); + } + if (_payload5429.vehicleUniqueId.isSome) { + ref _payload5556 = _payload5429.vehicleUniqueId.unwrap(); + *cast(ubyte*)(_retArea.ptr + (296+22*size_t.sizeof)) = cast(ubyte)(1); + *cast(ulong*)(_retArea.ptr + (304+22*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload5556)); + } else { + *cast(ubyte*)(_retArea.ptr + (296+22*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(double*)(_retArea.ptr + (312+22*size_t.sizeof)) = cast(double)(_payload5429.analogMove[0]); + *cast(double*)(_retArea.ptr + (320+22*size_t.sizeof)) = cast(double)(_payload5429.analogMove[1]); + *cast(double*)(_retArea.ptr + (328+22*size_t.sizeof)) = cast(double)(_payload5429.cameraOrientation[0]); + *cast(double*)(_retArea.ptr + (336+22*size_t.sizeof)) = cast(double)(_payload5429.cameraOrientation[1]); + *cast(double*)(_retArea.ptr + (344+22*size_t.sizeof)) = cast(double)(_payload5429.cameraOrientation[2]); + *cast(double*)(_retArea.ptr + (352+22*size_t.sizeof)) = cast(double)(_payload5429.rawMove[0]); + *cast(double*)(_retArea.ptr + (360+22*size_t.sizeof)) = cast(double)(_payload5429.rawMove[1]); + break; + } + case _Tag5590.sPlayerHotbar: { + ref wit.pumpkin.plugin.bedrock_packets.common.SPlayerHotbar _payload5558 = _payload5235.getSPlayerHotbar(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(19); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5558.selectedSlot)); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(cast(uint)(_payload5558.containerId)); + *cast(ubyte*)(_retArea.ptr + 37) = cast(ubyte)(cast(uint)(_payload5558.shouldSelectSlot)); + break; + } + case _Tag5590.sRequestAbility: { + ref wit.pumpkin.plugin.bedrock_packets.common.SRequestAbility _payload5560 = _payload5235.getSRequestAbility(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(20); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5560.ability)); + alias _Tag5565 = wit.pumpkin.plugin.bedrock_packets.common.AbilityValue.Tag; + final switch (_payload5560.value.tag) { + case _Tag5565.bool_: { + ref bool _payload5562 = _payload5560.value.getBool(); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(0); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(cast(uint)(_payload5562)); + break; + } + case _Tag5565.float_: { + ref float _payload5564 = _payload5560.value.getFloat(); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(1); + *cast(float*)(_retArea.ptr + 40) = cast(float)(_payload5564); + break; + } + } + break; + } + case _Tag5590.sRequestChunkRadius: { + ref wit.pumpkin.plugin.bedrock_packets.common.SRequestChunkRadius _payload5567 = _payload5235.getSRequestChunkRadius(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(21); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5567.chunkRadius)); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(cast(uint)(_payload5567.maxChunkRadius)); + break; + } + case _Tag5590.sRequestNetworkSettings: { + ref wit.pumpkin.plugin.bedrock_packets.common.SRequestNetworkSettings _payload5569 = _payload5235.getSRequestNetworkSettings(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(22); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5569.clientNetworkVersion)); + break; + } + case _Tag5590.sResourcePackClientResponse: { + ref wit.pumpkin.plugin.bedrock_packets.common.SResourcePackClientResponse _payload5571 = _payload5235.getSResourcePackClientResponse(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(23); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload5571.response)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5571.downloadSize)); + auto _listSrc5573 = _payload5571.packIds; + auto _list5573 = _listSrc5573.length ? wit.common.malloc(_listSrc5573.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5573.length || _list5573); + foreach (_elem5572_idx, ref _elem5572; _listSrc5573) { + auto _base5572 = _list5573 + _elem5572_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5572 + size_t.sizeof) = cast(size_t)(_elem5572.length); + *cast(void**)(_base5572 + 0) = cast(void*)(cast(void*)(_elem5572.ptr)); + + } + if (_listSrc5573.length) wit.common.free(_listSrc5573.ptr); + *cast(size_t*)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(size_t)(_payload5571.packIds.length); + *cast(void**)(_retArea.ptr + 40) = cast(void*)(_list5573); + break; + } + case _Tag5590.sRespawn: { + ref wit.pumpkin.plugin.bedrock_packets.common.SRespawn _payload5575 = _payload5235.getSRespawn(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(24); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload5575.position[0]); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload5575.position[1]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload5575.position[2]); + *cast(ubyte*)(_retArea.ptr + 56) = cast(ubyte)(cast(uint)(_payload5575.state)); + *cast(ulong*)(_retArea.ptr + 64) = cast(ulong)(cast(ulong)(_payload5575.playerRuntimeId)); + break; + } + case _Tag5590.sSetLocalPlayerAsInitialized: { + ref wit.pumpkin.plugin.bedrock_packets.common.SSetLocalPlayerAsInitialized _payload5577 = _payload5235.getSSetLocalPlayerAsInitialized(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(25); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload5577.playerId)); + break; + } + case _Tag5590.sSetPlayerInventoryOptions: { + ref wit.pumpkin.plugin.bedrock_packets.common.SSetPlayerInventoryOptions _payload5579 = _payload5235.getSSetPlayerInventoryOptions(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(26); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5579.leftInventoryTab)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5579.rightInventoryTab)); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(cast(uint)(_payload5579.filtering)); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload5579.layoutInv)); + *cast(uint*)(_retArea.ptr + 48) = cast(uint)(cast(uint)(_payload5579.layoutCraft)); + break; + } + case _Tag5590.sText: { + ref wit.pumpkin.plugin.bedrock_packets.common.SText _payload5581 = _payload5235.getSText(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(27); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload5581.needsTranslation)); + *cast(ubyte*)(_retArea.ptr + 33) = cast(ubyte)(cast(uint)(_payload5581.rType)); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload5581.sourceName.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5581.sourceName.ptr)); + *cast(size_t*)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(size_t)(_payload5581.message.length); + *cast(void**)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5581.message.ptr)); + auto _listSrc5583 = _payload5581.parameters; + auto _list5583 = _listSrc5583.length ? wit.common.malloc(_listSrc5583.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5583.length || _list5583); + foreach (_elem5582_idx, ref _elem5582; _listSrc5583) { + auto _base5582 = _list5583 + _elem5582_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5582 + size_t.sizeof) = cast(size_t)(_elem5582.length); + *cast(void**)(_base5582 + 0) = cast(void*)(cast(void*)(_elem5582.ptr)); + + } + if (_listSrc5583.length) wit.common.free(_listSrc5583.ptr); + *cast(size_t*)(_retArea.ptr + (32+6*size_t.sizeof)) = cast(size_t)(_payload5581.parameters.length); + *cast(void**)(_retArea.ptr + (32+5*size_t.sizeof)) = cast(void*)(_list5583); + *cast(size_t*)(_retArea.ptr + (32+8*size_t.sizeof)) = cast(size_t)(_payload5581.xuid.length); + *cast(void**)(_retArea.ptr + (32+7*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5581.xuid.ptr)); + *cast(size_t*)(_retArea.ptr + (32+10*size_t.sizeof)) = cast(size_t)(_payload5581.platformChatId.length); + *cast(void**)(_retArea.ptr + (32+9*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5581.platformChatId.ptr)); + if (_payload5581.filteredMessage.isSome) { + ref _payload5587 = _payload5581.filteredMessage.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+11*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+13*size_t.sizeof)) = cast(size_t)(_payload5587.length); + *cast(void**)(_retArea.ptr + (32+12*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5587.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (32+11*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag5590.unknown: { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(28); + break; + } + } + break; + } + case _Tag5593.unknown: { + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(2); + break; + } + } + *cast(uint*)(_retArea.ptr + (368+22*size_t.sizeof)) = cast(uint)(cast(uint)(_payload4979.packetId)); + *cast(size_t*)(_retArea.ptr + (368+24*size_t.sizeof)) = cast(size_t)(_payload4979.rawPayload.length); + *cast(void**)(_retArea.ptr + (368+23*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4979.rawPayload.ptr)); + *cast(ubyte*)(_retArea.ptr + (368+25*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload4979.cancelled)); + break; + } + case _Tag7236.packetSentEvent: { + ref wit.pumpkin.plugin.event.imports.PacketSentEventData _payload5595 = _ret.getPacketSentEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(43); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload5595.player.__handle); + alias _Tag6657 = wit.pumpkin.plugin.event.common.ClientboundPacket.Tag; + final switch (_payload5595.packet.tag) { + case _Tag6657.java: { + ref wit.pumpkin.plugin.event.common.JavaClientboundPacket _payload5597 = _payload5595.packet.getJava(); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(0); + alias _Tag6350 = wit.pumpkin.plugin.java_packets.common.ClientboundPacket.Tag; + final switch (_payload5597.tag) { + case _Tag6350.configCConfigAddResourcePack: { + ref wit.pumpkin.plugin.java_packets.common.ConfigCConfigAddResourcePack _payload5599 = _payload5597.getConfigCConfigAddResourcePack(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(0); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(_payload5599.uuid.high); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(_payload5599.uuid.low); + *cast(size_t*)(_retArea.ptr + (48+1*size_t.sizeof)) = cast(size_t)(_payload5599.url.length); + *cast(void**)(_retArea.ptr + 48) = cast(void*)(cast(void*)(_payload5599.url.ptr)); + *cast(size_t*)(_retArea.ptr + (48+3*size_t.sizeof)) = cast(size_t)(_payload5599.hash.length); + *cast(void**)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5599.hash.ptr)); + *cast(ubyte*)(_retArea.ptr + (48+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5599.forced)); + if (_payload5599.promptMessage.isSome) { + ref _payload5603 = _payload5599.promptMessage.unwrap(); + *cast(ubyte*)(_retArea.ptr + (48+5*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (48+7*size_t.sizeof)) = cast(size_t)(_payload5603.length); + *cast(void**)(_retArea.ptr + (48+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5603.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (48+5*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag6350.configCConfigClearDialog: { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(1); + break; + } + case _Tag6350.configCCodeOfConduct: { + ref wit.pumpkin.plugin.java_packets.common.ConfigCCodeOfConduct _payload5607 = _payload5597.getConfigCCodeOfConduct(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(2); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5607.codeOfConduct.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5607.codeOfConduct.ptr)); + break; + } + case _Tag6350.configCConfigDisconnect: { + ref wit.pumpkin.plugin.java_packets.common.ConfigCConfigDisconnect _payload5609 = _payload5597.getConfigCConfigDisconnect(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(3); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5609.reason.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5609.reason.ptr)); + break; + } + case _Tag6350.configCCookieRequest: { + ref wit.pumpkin.plugin.java_packets.common.ConfigCCookieRequest _payload5611 = _payload5597.getConfigCCookieRequest(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(4); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5611.key.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5611.key.ptr)); + break; + } + case _Tag6350.configCConfigCustomReportDetails: { + ref wit.pumpkin.plugin.java_packets.common.ConfigCConfigCustomReportDetails _payload5613 = _payload5597.getConfigCConfigCustomReportDetails(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(5); + auto _listSrc5615 = _payload5613.details; + auto _list5615 = _listSrc5615.length ? wit.common.malloc(_listSrc5615.length * ((4*size_t.sizeof))) : null; + assert(!_listSrc5615.length || _list5615); + foreach (_elem5614_idx, ref _elem5614; _listSrc5615) { + auto _base5614 = _list5615 + _elem5614_idx * ((4*size_t.sizeof)); + *cast(size_t*)(_base5614 + size_t.sizeof) = cast(size_t)(_elem5614[0].length); + *cast(void**)(_base5614 + 0) = cast(void*)(cast(void*)(_elem5614[0].ptr)); + *cast(size_t*)(_base5614 + (3*size_t.sizeof)) = cast(size_t)(_elem5614[1].length); + *cast(void**)(_base5614 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem5614[1].ptr)); + + } + if (_listSrc5615.length) wit.common.free(_listSrc5615.ptr); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5613.details.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(_list5615); + break; + } + case _Tag6350.configCFeatureFlags: { + ref wit.pumpkin.plugin.java_packets.common.ConfigCFeatureFlags _payload5617 = _payload5597.getConfigCFeatureFlags(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(6); + auto _listSrc5619 = _payload5617.features; + auto _list5619 = _listSrc5619.length ? wit.common.malloc(_listSrc5619.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5619.length || _list5619); + foreach (_elem5618_idx, ref _elem5618; _listSrc5619) { + auto _base5618 = _list5619 + _elem5618_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5618 + size_t.sizeof) = cast(size_t)(_elem5618.length); + *cast(void**)(_base5618 + 0) = cast(void*)(cast(void*)(_elem5618.ptr)); + + } + if (_listSrc5619.length) wit.common.free(_listSrc5619.ptr); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5617.features.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(_list5619); + break; + } + case _Tag6350.configCFinishConfig: { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(7); + break; + } + case _Tag6350.configCKnownPacks: { + ref wit.pumpkin.plugin.java_packets.common.ConfigCKnownPacks _payload5623 = _payload5597.getConfigCKnownPacks(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(8); + auto _listSrc5625 = _payload5623.knownPacks; + auto _list5625 = _listSrc5625.length ? wit.common.malloc(_listSrc5625.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5625.length || _list5625); + foreach (_elem5624_idx, ref _elem5624; _listSrc5625) { + auto _base5624 = _list5625 + _elem5624_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5624 + size_t.sizeof) = cast(size_t)(_elem5624.length); + *cast(void**)(_base5624 + 0) = cast(void*)(cast(void*)(_elem5624.ptr)); + + } + if (_listSrc5625.length) wit.common.free(_listSrc5625.ptr); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5623.knownPacks.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(_list5625); + break; + } + case _Tag6350.configCConfigPing: { + ref wit.pumpkin.plugin.java_packets.common.ConfigCConfigPing _payload5627 = _payload5597.getConfigCConfigPing(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(9); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5627.id)); + break; + } + case _Tag6350.configCPluginMessage: { + ref wit.pumpkin.plugin.java_packets.common.ConfigCPluginMessage _payload5629 = _payload5597.getConfigCPluginMessage(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(10); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5629.channel.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5629.channel.ptr)); + *cast(size_t*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(size_t)(_payload5629.data.length); + *cast(void**)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5629.data.ptr)); + break; + } + case _Tag6350.configCRegistryData: { + ref wit.pumpkin.plugin.java_packets.common.ConfigCRegistryData _payload5631 = _payload5597.getConfigCRegistryData(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(11); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5631.registryId.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5631.registryId.ptr)); + auto _listSrc5633 = _payload5631.entries; + auto _list5633 = _listSrc5633.length ? wit.common.malloc(_listSrc5633.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5633.length || _list5633); + foreach (_elem5632_idx, ref _elem5632; _listSrc5633) { + auto _base5632 = _list5633 + _elem5632_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5632 + size_t.sizeof) = cast(size_t)(_elem5632.length); + *cast(void**)(_base5632 + 0) = cast(void*)(cast(void*)(_elem5632.ptr)); + + } + if (_listSrc5633.length) wit.common.free(_listSrc5633.ptr); + *cast(size_t*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(size_t)(_payload5631.entries.length); + *cast(void**)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(void*)(_list5633); + break; + } + case _Tag6350.configCConfigRemoveResourcePack: { + ref wit.pumpkin.plugin.java_packets.common.ConfigCConfigRemoveResourcePack _payload5635 = _payload5597.getConfigCConfigRemoveResourcePack(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(12); + if (_payload5635.uuid.isSome) { + ref _payload5639 = _payload5635.uuid.unwrap(); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(1); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(_payload5639.high); + *cast(ulong*)(_retArea.ptr + 48) = cast(ulong)(_payload5639.low); + } else { + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(0); + } + break; + } + case _Tag6350.configCConfigResetChat: { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(13); + break; + } + case _Tag6350.configCConfigServerLinks: { + ref wit.pumpkin.plugin.java_packets.common.ConfigCConfigServerLinks _payload5643 = _payload5597.getConfigCConfigServerLinks(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(14); + auto _listSrc5645 = _payload5643.links; + auto _list5645 = _listSrc5645.length ? wit.common.malloc(_listSrc5645.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5645.length || _list5645); + foreach (_elem5644_idx, ref _elem5644; _listSrc5645) { + auto _base5644 = _list5645 + _elem5644_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5644 + size_t.sizeof) = cast(size_t)(_elem5644.length); + *cast(void**)(_base5644 + 0) = cast(void*)(cast(void*)(_elem5644.ptr)); + + } + if (_listSrc5645.length) wit.common.free(_listSrc5645.ptr); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5643.links.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(_list5645); + break; + } + case _Tag6350.configCConfigShowDialog: { + ref wit.pumpkin.plugin.java_packets.common.ConfigCConfigShowDialog _payload5647 = _payload5597.getConfigCConfigShowDialog(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(15); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5647.dialog.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5647.dialog.ptr)); + break; + } + case _Tag6350.configCStoreCookie: { + ref wit.pumpkin.plugin.java_packets.common.ConfigCStoreCookie _payload5649 = _payload5597.getConfigCStoreCookie(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(16); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5649.key.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5649.key.ptr)); + *cast(size_t*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(size_t)(_payload5649.payload.length); + *cast(void**)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5649.payload.ptr)); + break; + } + case _Tag6350.configCTransfer: { + ref wit.pumpkin.plugin.java_packets.common.ConfigCTransfer _payload5651 = _payload5597.getConfigCTransfer(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(17); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5651.host.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5651.host.ptr)); + *cast(uint*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5651.port)); + break; + } + case _Tag6350.configCUpdateTags: { + ref wit.pumpkin.plugin.java_packets.common.ConfigCUpdateTags _payload5653 = _payload5597.getConfigCUpdateTags(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(18); + auto _listSrc5655 = _payload5653.tags; + auto _list5655 = _listSrc5655.length ? wit.common.malloc(_listSrc5655.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5655.length || _list5655); + foreach (_elem5654_idx, ref _elem5654; _listSrc5655) { + auto _base5654 = _list5655 + _elem5654_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5654 + size_t.sizeof) = cast(size_t)(_elem5654.length); + *cast(void**)(_base5654 + 0) = cast(void*)(cast(void*)(_elem5654.ptr)); + + } + if (_listSrc5655.length) wit.common.free(_listSrc5655.ptr); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5653.tags.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(_list5655); + break; + } + case _Tag6350.loginCLoginCookieRequest: { + ref wit.pumpkin.plugin.java_packets.common.LoginCLoginCookieRequest _payload5657 = _payload5597.getLoginCLoginCookieRequest(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(19); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5657.key.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5657.key.ptr)); + break; + } + case _Tag6350.loginCLoginDisconnect: { + ref wit.pumpkin.plugin.java_packets.common.LoginCLoginDisconnect _payload5659 = _payload5597.getLoginCLoginDisconnect(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(20); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5659.jsonReason.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5659.jsonReason.ptr)); + break; + } + case _Tag6350.loginCLoginPluginRequest: { + ref wit.pumpkin.plugin.java_packets.common.LoginCLoginPluginRequest _payload5661 = _payload5597.getLoginCLoginPluginRequest(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(21); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5661.messageId)); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload5661.channel.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5661.channel.ptr)); + *cast(size_t*)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(size_t)(_payload5661.data.length); + *cast(void**)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5661.data.ptr)); + break; + } + case _Tag6350.loginCSetCompression: { + ref wit.pumpkin.plugin.java_packets.common.LoginCSetCompression _payload5663 = _payload5597.getLoginCSetCompression(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(22); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5663.threshold)); + break; + } + case _Tag6350.cAcknowledgeBlockChange: { + ref wit.pumpkin.plugin.java_packets.common.CAcknowledgeBlockChange _payload5665 = _payload5597.getCAcknowledgeBlockChange(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(23); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5665.sequenceId)); + break; + } + case _Tag6350.cActionBar: { + ref wit.pumpkin.plugin.java_packets.common.CActionBar _payload5667 = _payload5597.getCActionBar(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(24); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5667.actionBar.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5667.actionBar.ptr)); + break; + } + case _Tag6350.cAddResourcePack: { + ref wit.pumpkin.plugin.java_packets.common.CAddResourcePack _payload5669 = _payload5597.getCAddResourcePack(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(25); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(_payload5669.uuid.high); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(_payload5669.uuid.low); + *cast(size_t*)(_retArea.ptr + (48+1*size_t.sizeof)) = cast(size_t)(_payload5669.url.length); + *cast(void**)(_retArea.ptr + 48) = cast(void*)(cast(void*)(_payload5669.url.ptr)); + *cast(size_t*)(_retArea.ptr + (48+3*size_t.sizeof)) = cast(size_t)(_payload5669.hash.length); + *cast(void**)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5669.hash.ptr)); + *cast(ubyte*)(_retArea.ptr + (48+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5669.forced)); + if (_payload5669.promptMessage.isSome) { + ref _payload5673 = _payload5669.promptMessage.unwrap(); + *cast(ubyte*)(_retArea.ptr + (48+5*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (48+7*size_t.sizeof)) = cast(size_t)(_payload5673.length); + *cast(void**)(_retArea.ptr + (48+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5673.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (48+5*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag6350.cAwardStats: { + ref wit.pumpkin.plugin.java_packets.common.CAwardStats _payload5675 = _payload5597.getCAwardStats(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(26); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5675.stats.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5675.stats.ptr)); + break; + } + case _Tag6350.cSetBlockDestroyStage: { + ref wit.pumpkin.plugin.java_packets.common.CSetBlockDestroyStage _payload5677 = _payload5597.getCSetBlockDestroyStage(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(27); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5677.entityId)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5677.location[0])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5677.location[1])); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload5677.location[2])); + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(cast(uint)(_payload5677.destroyStage)); + break; + } + case _Tag6350.cBlockEntityData: { + ref wit.pumpkin.plugin.java_packets.common.CBlockEntityData _payload5679 = _payload5597.getCBlockEntityData(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(28); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5679.location[0])); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5679.location[1])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5679.location[2])); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload5679.rType)); + *cast(size_t*)(_retArea.ptr + (48+1*size_t.sizeof)) = cast(size_t)(_payload5679.nbtData.length); + *cast(void**)(_retArea.ptr + 48) = cast(void*)(cast(void*)(_payload5679.nbtData.ptr)); + break; + } + case _Tag6350.cBlockEvent: { + ref wit.pumpkin.plugin.java_packets.common.CBlockEvent _payload5681 = _payload5597.getCBlockEvent(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(29); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5681.location[0])); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5681.location[1])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5681.location[2])); + *cast(ubyte*)(_retArea.ptr + 44) = cast(ubyte)(cast(uint)(_payload5681.actionId)); + *cast(ubyte*)(_retArea.ptr + 45) = cast(ubyte)(cast(uint)(_payload5681.actionParameter)); + *cast(uint*)(_retArea.ptr + 48) = cast(uint)(cast(uint)(_payload5681.blockType)); + break; + } + case _Tag6350.cBlockUpdate: { + ref wit.pumpkin.plugin.java_packets.common.CBlockUpdate _payload5683 = _payload5597.getCBlockUpdate(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(30); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5683.location[0])); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5683.location[1])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5683.location[2])); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload5683.stateId)); + break; + } + case _Tag6350.cBossEvent: { + ref wit.pumpkin.plugin.java_packets.common.CBossEvent _payload5685 = _payload5597.getCBossEvent(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(31); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(_payload5685.uuid.high); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(_payload5685.uuid.low); + alias _Tag5698 = wit.pumpkin.plugin.java_packets.common.BosseventAction.Tag; + final switch (_payload5685.action.tag) { + case _Tag5698.add: { + ref wit.pumpkin.plugin.java_packets.common.BosseventActionAdd _payload5687 = _payload5685.action.getAdd(); + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(0); + *cast(size_t*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(size_t)(_payload5687.title.length); + *cast(void**)(_retArea.ptr + (48+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5687.title.ptr)); + *cast(float*)(_retArea.ptr + (48+3*size_t.sizeof)) = cast(float)(_payload5687.health); + *cast(uint*)(_retArea.ptr + (52+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5687.color)); + *cast(uint*)(_retArea.ptr + (56+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5687.division)); + *cast(ubyte*)(_retArea.ptr + (60+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5687.flags)); + break; + } + case _Tag5698.remove: { + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(1); + break; + } + case _Tag5698.updateHealth: { + ref float _payload5691 = _payload5685.action.getUpdateHealth(); + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(2); + *cast(float*)(_retArea.ptr + (48+1*size_t.sizeof)) = cast(float)(_payload5691); + break; + } + case _Tag5698.updateTile: { + ref WitString _payload5693 = _payload5685.action.getUpdateTile(); + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(3); + *cast(size_t*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(size_t)(_payload5693.length); + *cast(void**)(_retArea.ptr + (48+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5693.ptr)); + break; + } + case _Tag5698.updateStyle: { + ref wit.pumpkin.plugin.java_packets.common.BosseventActionUpdateStyle _payload5695 = _payload5685.action.getUpdateStyle(); + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(4); + *cast(uint*)(_retArea.ptr + (48+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5695.color)); + *cast(uint*)(_retArea.ptr + (52+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5695.dividers)); + break; + } + case _Tag5698.updateFlags: { + ref ubyte _payload5697 = _payload5685.action.getUpdateFlags(); + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(5); + *cast(ubyte*)(_retArea.ptr + (48+1*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5697)); + break; + } + } + break; + } + case _Tag6350.cBundleDelimiter: { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(32); + break; + } + case _Tag6350.cCenterChunk: { + ref wit.pumpkin.plugin.java_packets.common.CCenterChunk _payload5702 = _payload5597.getCCenterChunk(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(33); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5702.chunkX)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5702.chunkZ)); + break; + } + case _Tag6350.cChangeDifficulty: { + ref wit.pumpkin.plugin.java_packets.common.CChangeDifficulty _payload5704 = _payload5597.getCChangeDifficulty(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(34); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload5704.difficulty)); + *cast(ubyte*)(_retArea.ptr + 33) = cast(ubyte)(cast(uint)(_payload5704.locked)); + break; + } + case _Tag6350.cChunkBatchEnd: { + ref wit.pumpkin.plugin.java_packets.common.CChunkBatchEnd _payload5706 = _payload5597.getCChunkBatchEnd(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(35); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5706.batchSize)); + break; + } + case _Tag6350.cChunkBatchStart: { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(36); + break; + } + case _Tag6350.cChunksBiomes: { + ref wit.pumpkin.plugin.java_packets.common.CChunksBiomes _payload5710 = _payload5597.getCChunksBiomes(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(37); + auto _listSrc5712 = _payload5710.chunks; + auto _list5712 = _listSrc5712.length ? wit.common.malloc(_listSrc5712.length * ((8+2*size_t.sizeof))) : null; + assert(!_listSrc5712.length || _list5712); + foreach (_elem5711_idx, ref _elem5711; _listSrc5712) { + auto _base5711 = _list5712 + _elem5711_idx * ((8+2*size_t.sizeof)); + *cast(uint*)(_base5711 + 0) = cast(uint)(cast(uint)(_elem5711.chunkX)); + *cast(uint*)(_base5711 + 4) = cast(uint)(cast(uint)(_elem5711.chunkZ)); + *cast(size_t*)(_base5711 + (8+1*size_t.sizeof)) = cast(size_t)(_elem5711.data.length); + *cast(void**)(_base5711 + 8) = cast(void*)(cast(void*)(_elem5711.data.ptr)); + + } + if (_listSrc5712.length) wit.common.free(_listSrc5712.ptr); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5710.chunks.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(_list5712); + break; + } + case _Tag6350.cPlayClearDialog: { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(38); + break; + } + case _Tag6350.cClearTitle: { + ref wit.pumpkin.plugin.java_packets.common.CClearTitle _payload5716 = _payload5597.getCClearTitle(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(39); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload5716.reset)); + break; + } + case _Tag6350.cCloseContainer: { + ref wit.pumpkin.plugin.java_packets.common.CCloseContainer _payload5718 = _payload5597.getCCloseContainer(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(40); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5718.syncId)); + break; + } + case _Tag6350.cCombatDeath: { + ref wit.pumpkin.plugin.java_packets.common.CCombatDeath _payload5720 = _payload5597.getCCombatDeath(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(41); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5720.playerId)); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload5720.message.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5720.message.ptr)); + break; + } + case _Tag6350.cCombatEnter: { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(42); + break; + } + case _Tag6350.cCombatEnd: { + ref wit.pumpkin.plugin.java_packets.common.CCombatEnd _payload5724 = _payload5597.getCCombatEnd(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(43); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5724.durationTicks)); + break; + } + case _Tag6350.cCommandSuggestions: { + ref wit.pumpkin.plugin.java_packets.common.CCommandSuggestions _payload5726 = _payload5597.getCCommandSuggestions(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(44); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5726.id)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5726.start)); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5726.length)); + auto _listSrc5732 = _payload5726.matches; + auto _list5732 = _listSrc5732.length ? wit.common.malloc(_listSrc5732.length * ((5*size_t.sizeof))) : null; + assert(!_listSrc5732.length || _list5732); + foreach (_elem5727_idx, ref _elem5727; _listSrc5732) { + auto _base5727 = _list5732 + _elem5727_idx * ((5*size_t.sizeof)); + *cast(size_t*)(_base5727 + size_t.sizeof) = cast(size_t)(_elem5727.suggestion.length); + *cast(void**)(_base5727 + 0) = cast(void*)(cast(void*)(_elem5727.suggestion.ptr)); + if (_elem5727.tooltip.isSome) { + ref _payload5731 = _elem5727.tooltip.unwrap(); + *cast(ubyte*)(_base5727 + (2*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_base5727 + (4*size_t.sizeof)) = cast(size_t)(_payload5731.length); + *cast(void**)(_base5727 + (3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5731.ptr)); + } else { + *cast(ubyte*)(_base5727 + (2*size_t.sizeof)) = cast(ubyte)(0); + } + + } + if (_listSrc5732.length) wit.common.free(_listSrc5732.ptr); + *cast(size_t*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(size_t)(_payload5726.matches.length); + *cast(void**)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(void*)(_list5732); + break; + } + case _Tag6350.cCommands: { + ref wit.pumpkin.plugin.java_packets.common.CCommands _payload5734 = _payload5597.getCCommands(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(45); + auto _listSrc5902 = _payload5734.nodes; + auto _list5902 = _listSrc5902.length ? wit.common.malloc(_listSrc5902.length * ((72+4*size_t.sizeof))) : null; + assert(!_listSrc5902.length || _list5902); + foreach (_elem5735_idx, ref _elem5735; _listSrc5902) { + auto _base5735 = _list5902 + _elem5735_idx * ((72+4*size_t.sizeof)); + *cast(size_t*)(_base5735 + size_t.sizeof) = cast(size_t)(_elem5735.children.length); + *cast(void**)(_base5735 + 0) = cast(void*)(cast(void*)(_elem5735.children.ptr)); + alias _Tag5901 = wit.pumpkin.plugin.java_packets.common.ProtoNodeType.Tag; + final switch (_elem5735.nodeType.tag) { + case _Tag5901.root: { + *cast(ubyte*)(_base5735 + (2*size_t.sizeof)) = cast(ubyte)(0); + break; + } + case _Tag5901.literal: { + ref wit.pumpkin.plugin.java_packets.common.ProtoNodeTypeLiteral _payload5739 = _elem5735.nodeType.getLiteral(); + *cast(ubyte*)(_base5735 + (2*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_base5735 + (8+3*size_t.sizeof)) = cast(size_t)(_payload5739.name.length); + *cast(void**)(_base5735 + (8+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5739.name.ptr)); + *cast(ubyte*)(_base5735 + (8+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5739.isExecutable)); + if (_payload5739.redirectTarget.isSome) { + ref _payload5743 = _payload5739.redirectTarget.unwrap(); + *cast(ubyte*)(_base5735 + (12+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base5735 + (16+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5743)); + } else { + *cast(ubyte*)(_base5735 + (12+4*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base5735 + (20+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5739.restricted)); + break; + } + case _Tag5901.argument: { + ref wit.pumpkin.plugin.java_packets.common.ProtoNodeTypeArgument _payload5745 = _elem5735.nodeType.getArgument(); + *cast(ubyte*)(_base5735 + (2*size_t.sizeof)) = cast(ubyte)(2); + *cast(size_t*)(_base5735 + (8+3*size_t.sizeof)) = cast(size_t)(_payload5745.name.length); + *cast(void**)(_base5735 + (8+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5745.name.ptr)); + *cast(ubyte*)(_base5735 + (8+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5745.isExecutable)); + if (_payload5745.redirectTarget.isSome) { + ref _payload5749 = _payload5745.redirectTarget.unwrap(); + *cast(ubyte*)(_base5735 + (12+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base5735 + (16+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5749)); + } else { + *cast(ubyte*)(_base5735 + (12+4*size_t.sizeof)) = cast(ubyte)(0); + } + alias _Tag5896 = wit.pumpkin.plugin.java_packets.common.ArgumentType.Tag; + final switch (_payload5745.parser.tag) { + case _Tag5896.bool_: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(0); + break; + } + case _Tag5896.float_: { + ref wit.pumpkin.plugin.java_packets.common.ArgumentTypeFloat _payload5753 = _payload5745.parser.getFloat(); + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(1); + if (_payload5753.min.isSome) { + ref _payload5757 = _payload5753.min.unwrap(); + *cast(ubyte*)(_base5735 + (32+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(float*)(_base5735 + (36+4*size_t.sizeof)) = cast(float)(_payload5757); + } else { + *cast(ubyte*)(_base5735 + (32+4*size_t.sizeof)) = cast(ubyte)(0); + } + if (_payload5753.max.isSome) { + ref _payload5761 = _payload5753.max.unwrap(); + *cast(ubyte*)(_base5735 + (40+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(float*)(_base5735 + (44+4*size_t.sizeof)) = cast(float)(_payload5761); + } else { + *cast(ubyte*)(_base5735 + (40+4*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag5896.double_: { + ref wit.pumpkin.plugin.java_packets.common.ArgumentTypeDouble _payload5763 = _payload5745.parser.getDouble(); + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(2); + if (_payload5763.min.isSome) { + ref _payload5767 = _payload5763.min.unwrap(); + *cast(ubyte*)(_base5735 + (32+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(double*)(_base5735 + (40+4*size_t.sizeof)) = cast(double)(_payload5767); + } else { + *cast(ubyte*)(_base5735 + (32+4*size_t.sizeof)) = cast(ubyte)(0); + } + if (_payload5763.max.isSome) { + ref _payload5771 = _payload5763.max.unwrap(); + *cast(ubyte*)(_base5735 + (48+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(double*)(_base5735 + (56+4*size_t.sizeof)) = cast(double)(_payload5771); + } else { + *cast(ubyte*)(_base5735 + (48+4*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag5896.integer: { + ref wit.pumpkin.plugin.java_packets.common.ArgumentTypeInteger _payload5773 = _payload5745.parser.getInteger(); + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(3); + if (_payload5773.min.isSome) { + ref _payload5777 = _payload5773.min.unwrap(); + *cast(ubyte*)(_base5735 + (32+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base5735 + (36+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5777)); + } else { + *cast(ubyte*)(_base5735 + (32+4*size_t.sizeof)) = cast(ubyte)(0); + } + if (_payload5773.max.isSome) { + ref _payload5781 = _payload5773.max.unwrap(); + *cast(ubyte*)(_base5735 + (40+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base5735 + (44+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5781)); + } else { + *cast(ubyte*)(_base5735 + (40+4*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag5896.long_: { + ref wit.pumpkin.plugin.java_packets.common.ArgumentTypeLong _payload5783 = _payload5745.parser.getLong(); + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(4); + if (_payload5783.min.isSome) { + ref _payload5787 = _payload5783.min.unwrap(); + *cast(ubyte*)(_base5735 + (32+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(ulong*)(_base5735 + (40+4*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload5787)); + } else { + *cast(ubyte*)(_base5735 + (32+4*size_t.sizeof)) = cast(ubyte)(0); + } + if (_payload5783.max.isSome) { + ref _payload5791 = _payload5783.max.unwrap(); + *cast(ubyte*)(_base5735 + (48+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(ulong*)(_base5735 + (56+4*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload5791)); + } else { + *cast(ubyte*)(_base5735 + (48+4*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag5896.string: { + ref wit.pumpkin.plugin.java_packets.common.StringProtoArgBehavior _payload5793 = _payload5745.parser.getString(); + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(5); + *cast(ubyte*)(_base5735 + (32+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5793)); + break; + } + case _Tag5896.entity: { + ref wit.pumpkin.plugin.java_packets.common.ArgumentTypeEntity _payload5795 = _payload5745.parser.getEntity(); + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(6); + *cast(ubyte*)(_base5735 + (32+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5795.flags)); + break; + } + case _Tag5896.gameProfile: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(7); + break; + } + case _Tag5896.blockPos: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(8); + break; + } + case _Tag5896.columnPos: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(9); + break; + } + case _Tag5896.vec3: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(10); + break; + } + case _Tag5896.vec2: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(11); + break; + } + case _Tag5896.blockState: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(12); + break; + } + case _Tag5896.blockPredicate: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(13); + break; + } + case _Tag5896.itemStack: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(14); + break; + } + case _Tag5896.itemPredicate: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(15); + break; + } + case _Tag5896.color: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(16); + break; + } + case _Tag5896.hexColor: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(17); + break; + } + case _Tag5896.component: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(18); + break; + } + case _Tag5896.style: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(19); + break; + } + case _Tag5896.message: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(20); + break; + } + case _Tag5896.nbtCompound: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(21); + break; + } + case _Tag5896.nbtTag: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(22); + break; + } + case _Tag5896.nbtPath: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(23); + break; + } + case _Tag5896.objective: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(24); + break; + } + case _Tag5896.objectiveCriteria: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(25); + break; + } + case _Tag5896.operation: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(26); + break; + } + case _Tag5896.particle: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(27); + break; + } + case _Tag5896.angle: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(28); + break; + } + case _Tag5896.rotation: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(29); + break; + } + case _Tag5896.scoreboardSlot: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(30); + break; + } + case _Tag5896.scoreHolder: { + ref wit.pumpkin.plugin.java_packets.common.ArgumentTypeScoreHolder _payload5845 = _payload5745.parser.getScoreHolder(); + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(31); + *cast(ubyte*)(_base5735 + (32+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5845.flags)); + break; + } + case _Tag5896.swizzle: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(32); + break; + } + case _Tag5896.team: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(33); + break; + } + case _Tag5896.itemSlot: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(34); + break; + } + case _Tag5896.itemSlots: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(35); + break; + } + case _Tag5896.resourceLocation: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(36); + break; + } + case _Tag5896.function_: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(37); + break; + } + case _Tag5896.entityAnchor: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(38); + break; + } + case _Tag5896.intRange: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(39); + break; + } + case _Tag5896.floatRange: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(40); + break; + } + case _Tag5896.dimension: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(41); + break; + } + case _Tag5896.gamemode: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(42); + break; + } + case _Tag5896.time: { + ref wit.pumpkin.plugin.java_packets.common.ArgumentTypeTime _payload5869 = _payload5745.parser.getTime(); + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(43); + *cast(uint*)(_base5735 + (32+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5869.min)); + break; + } + case _Tag5896.resourceOrTag: { + ref wit.pumpkin.plugin.java_packets.common.ArgumentTypeResourceOrTag _payload5871 = _payload5745.parser.getResourceOrTag(); + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(44); + *cast(size_t*)(_base5735 + (32+5*size_t.sizeof)) = cast(size_t)(_payload5871.identifier.length); + *cast(void**)(_base5735 + (32+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5871.identifier.ptr)); + break; + } + case _Tag5896.resourceOrTagKey: { + ref wit.pumpkin.plugin.java_packets.common.ArgumentTypeResourceOrTagKey _payload5873 = _payload5745.parser.getResourceOrTagKey(); + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(45); + *cast(size_t*)(_base5735 + (32+5*size_t.sizeof)) = cast(size_t)(_payload5873.identifier.length); + *cast(void**)(_base5735 + (32+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5873.identifier.ptr)); + break; + } + case _Tag5896.resource: { + ref wit.pumpkin.plugin.java_packets.common.ArgumentTypeResource _payload5875 = _payload5745.parser.getResource(); + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(46); + *cast(size_t*)(_base5735 + (32+5*size_t.sizeof)) = cast(size_t)(_payload5875.identifier.length); + *cast(void**)(_base5735 + (32+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5875.identifier.ptr)); + break; + } + case _Tag5896.resourceKey: { + ref wit.pumpkin.plugin.java_packets.common.ArgumentTypeResourceKey _payload5877 = _payload5745.parser.getResourceKey(); + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(47); + *cast(size_t*)(_base5735 + (32+5*size_t.sizeof)) = cast(size_t)(_payload5877.identifier.length); + *cast(void**)(_base5735 + (32+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5877.identifier.ptr)); + break; + } + case _Tag5896.resourceSelector: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(48); + break; + } + case _Tag5896.templateMirror: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(49); + break; + } + case _Tag5896.templateRotation: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(50); + break; + } + case _Tag5896.heightmap: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(51); + break; + } + case _Tag5896.lootTable: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(52); + break; + } + case _Tag5896.lootPredicate: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(53); + break; + } + case _Tag5896.lootModifier: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(54); + break; + } + case _Tag5896.dialog: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(55); + break; + } + case _Tag5896.uuid: { + *cast(ubyte*)(_base5735 + (24+4*size_t.sizeof)) = cast(ubyte)(56); + break; + } + } + if (_payload5745.overrideSuggestionType.isSome) { + ref _payload5900 = _payload5745.overrideSuggestionType.unwrap(); + *cast(ubyte*)(_base5735 + (64+4*size_t.sizeof)) = cast(ubyte)(1); + *cast(ubyte*)(_base5735 + (65+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5900)); + } else { + *cast(ubyte*)(_base5735 + (64+4*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base5735 + (66+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5745.restricted)); + break; + } + } + + } + if (_listSrc5902.length) wit.common.free(_listSrc5902.ptr); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5734.nodes.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(_list5902); + *cast(uint*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5734.rootNodeIndex)); + break; + } + case _Tag6350.cPlayCookieRequest: { + ref wit.pumpkin.plugin.java_packets.common.CPlayCookieRequest _payload5904 = _payload5597.getCPlayCookieRequest(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(46); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5904.key.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5904.key.ptr)); + break; + } + case _Tag6350.cCustomChatCompletions: { + ref wit.pumpkin.plugin.java_packets.common.CCustomChatCompletions _payload5906 = _payload5597.getCCustomChatCompletions(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(47); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5906.action)); + auto _listSrc5908 = _payload5906.entries; + auto _list5908 = _listSrc5908.length ? wit.common.malloc(_listSrc5908.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5908.length || _list5908); + foreach (_elem5907_idx, ref _elem5907; _listSrc5908) { + auto _base5907 = _list5908 + _elem5907_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5907 + size_t.sizeof) = cast(size_t)(_elem5907.length); + *cast(void**)(_base5907 + 0) = cast(void*)(cast(void*)(_elem5907.ptr)); + + } + if (_listSrc5908.length) wit.common.free(_listSrc5908.ptr); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload5906.entries.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(_list5908); + break; + } + case _Tag6350.cCustomPayload: { + ref wit.pumpkin.plugin.java_packets.common.CCustomPayload _payload5910 = _payload5597.getCCustomPayload(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(48); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5910.channel.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5910.channel.ptr)); + *cast(size_t*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(size_t)(_payload5910.data.length); + *cast(void**)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5910.data.ptr)); + break; + } + case _Tag6350.cPlayCustomReportDetails: { + ref wit.pumpkin.plugin.java_packets.common.CPlayCustomReportDetails _payload5912 = _payload5597.getCPlayCustomReportDetails(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(49); + auto _listSrc5914 = _payload5912.details; + auto _list5914 = _listSrc5914.length ? wit.common.malloc(_listSrc5914.length * ((4*size_t.sizeof))) : null; + assert(!_listSrc5914.length || _list5914); + foreach (_elem5913_idx, ref _elem5913; _listSrc5914) { + auto _base5913 = _list5914 + _elem5913_idx * ((4*size_t.sizeof)); + *cast(size_t*)(_base5913 + size_t.sizeof) = cast(size_t)(_elem5913[0].length); + *cast(void**)(_base5913 + 0) = cast(void*)(cast(void*)(_elem5913[0].ptr)); + *cast(size_t*)(_base5913 + (3*size_t.sizeof)) = cast(size_t)(_elem5913[1].length); + *cast(void**)(_base5913 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem5913[1].ptr)); + + } + if (_listSrc5914.length) wit.common.free(_listSrc5914.ptr); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5912.details.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(_list5914); + break; + } + case _Tag6350.cDamageEvent: { + ref wit.pumpkin.plugin.java_packets.common.CDamageEvent _payload5916 = _payload5597.getCDamageEvent(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(50); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5916.entityId)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5916.sourceTypeId)); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5916.sourceCauseId)); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload5916.sourceDirectId)); + if (_payload5916.sourcePosition.isSome) { + ref _payload5920 = _payload5916.sourcePosition.unwrap(); + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(1); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload5920[0]); + *cast(double*)(_retArea.ptr + 64) = cast(double)(_payload5920[1]); + *cast(double*)(_retArea.ptr + 72) = cast(double)(_payload5920[2]); + } else { + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(0); + } + break; + } + case _Tag6350.cDebugBlockValue: { + ref wit.pumpkin.plugin.java_packets.common.CDebugBlockValue _payload5922 = _payload5597.getCDebugBlockValue(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(51); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5922.pos[0])); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5922.pos[1])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5922.pos[2])); + *cast(size_t*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(size_t)(_payload5922.name.length); + *cast(void**)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5922.name.ptr)); + *cast(size_t*)(_retArea.ptr + (40+4*size_t.sizeof)) = cast(size_t)(_payload5922.value.length); + *cast(void**)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5922.value.ptr)); + break; + } + case _Tag6350.cDebugChunkValue: { + ref wit.pumpkin.plugin.java_packets.common.CDebugChunkValue _payload5924 = _payload5597.getCDebugChunkValue(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(52); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload5924.chunkPos[0]); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload5924.chunkPos[1]); + *cast(size_t*)(_retArea.ptr + (48+1*size_t.sizeof)) = cast(size_t)(_payload5924.name.length); + *cast(void**)(_retArea.ptr + 48) = cast(void*)(cast(void*)(_payload5924.name.ptr)); + *cast(size_t*)(_retArea.ptr + (48+3*size_t.sizeof)) = cast(size_t)(_payload5924.value.length); + *cast(void**)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5924.value.ptr)); + break; + } + case _Tag6350.cDebugEntityValue: { + ref wit.pumpkin.plugin.java_packets.common.CDebugEntityValue _payload5926 = _payload5597.getCDebugEntityValue(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(53); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5926.entityId)); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload5926.name.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5926.name.ptr)); + *cast(size_t*)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(size_t)(_payload5926.value.length); + *cast(void**)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5926.value.ptr)); + break; + } + case _Tag6350.cDebugEvent: { + ref wit.pumpkin.plugin.java_packets.common.CDebugEvent _payload5928 = _payload5597.getCDebugEvent(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(54); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5928.name.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5928.name.ptr)); + *cast(size_t*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(size_t)(_payload5928.data.length); + *cast(void**)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5928.data.ptr)); + break; + } + case _Tag6350.cDebugSample: { + ref wit.pumpkin.plugin.java_packets.common.CDebugSample _payload5930 = _payload5597.getCDebugSample(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(55); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5930.sample.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5930.sample.ptr)); + *cast(uint*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5930.sampleType)); + break; + } + case _Tag6350.cDeleteChat: { + ref wit.pumpkin.plugin.java_packets.common.CDeleteChat _payload5932 = _payload5597.getCDeleteChat(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(56); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5932.signatureId)); + if (_payload5932.signature.isSome) { + ref _payload5936 = _payload5932.signature.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(size_t)(_payload5936.length); + *cast(void**)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5936.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag6350.cPlayDisconnect: { + ref wit.pumpkin.plugin.java_packets.common.CPlayDisconnect _payload5938 = _payload5597.getCPlayDisconnect(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(57); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5938.reason.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5938.reason.ptr)); + break; + } + case _Tag6350.cDisguisedChatMessage: { + ref wit.pumpkin.plugin.java_packets.common.CDisguisedChatMessage _payload5940 = _payload5597.getCDisguisedChatMessage(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(58); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5940.message.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5940.message.ptr)); + *cast(uint*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5940.chatType)); + *cast(size_t*)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(size_t)(_payload5940.senderName.length); + *cast(void**)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5940.senderName.ptr)); + if (_payload5940.targetName.isSome) { + ref _payload5944 = _payload5940.targetName.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+5*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+7*size_t.sizeof)) = cast(size_t)(_payload5944.length); + *cast(void**)(_retArea.ptr + (32+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5944.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (32+5*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag6350.cDisplayObjective: { + ref wit.pumpkin.plugin.java_packets.common.CDisplayObjective _payload5946 = _payload5597.getCDisplayObjective(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(59); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5946.position)); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload5946.scoreName.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5946.scoreName.ptr)); + break; + } + case _Tag6350.cEntityAnimation: { + ref wit.pumpkin.plugin.java_packets.common.CEntityAnimation _payload5948 = _payload5597.getCEntityAnimation(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(60); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5948.entityId)); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(cast(uint)(_payload5948.animation)); + break; + } + case _Tag6350.cSetEntityMetadata: { + ref wit.pumpkin.plugin.java_packets.common.CSetEntityMetadata _payload5950 = _payload5597.getCSetEntityMetadata(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(61); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5950.entityId)); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload5950.metadata.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5950.metadata.ptr)); + break; + } + case _Tag6350.cEntitySoundEffect: { + ref wit.pumpkin.plugin.java_packets.common.CEntitySoundEffect _payload5952 = _payload5597.getCEntitySoundEffect(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(62); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5952.soundEvent.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5952.soundEvent.ptr)); + *cast(uint*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5952.soundCategory)); + *cast(uint*)(_retArea.ptr + (36+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5952.entityId)); + *cast(float*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(float)(_payload5952.volume); + *cast(float*)(_retArea.ptr + (44+2*size_t.sizeof)) = cast(float)(_payload5952.pitch); + *cast(ulong*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload5952.seed)); + break; + } + case _Tag6350.cEntityStatus: { + ref wit.pumpkin.plugin.java_packets.common.CEntityStatus _payload5954 = _payload5597.getCEntityStatus(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(63); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5954.entityId)); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(cast(uint)(_payload5954.entityStatus)); + break; + } + case _Tag6350.cEntityVelocity: { + ref wit.pumpkin.plugin.java_packets.common.CEntityVelocity _payload5956 = _payload5597.getCEntityVelocity(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(64); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5956.entityId)); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload5956.velocity.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5956.velocity.ptr)); + break; + } + case _Tag6350.cExplosion: { + ref wit.pumpkin.plugin.java_packets.common.CExplosion _payload5958 = _payload5597.getCExplosion(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(65); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload5958.center[0]); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload5958.center[1]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload5958.center[2]); + *cast(float*)(_retArea.ptr + 56) = cast(float)(_payload5958.radius); + *cast(uint*)(_retArea.ptr + 60) = cast(uint)(cast(uint)(_payload5958.blockCount)); + if (_payload5958.knockback.isSome) { + ref _payload5962 = _payload5958.knockback.unwrap(); + *cast(ubyte*)(_retArea.ptr + 64) = cast(ubyte)(1); + *cast(double*)(_retArea.ptr + 72) = cast(double)(_payload5962[0]); + *cast(double*)(_retArea.ptr + 80) = cast(double)(_payload5962[1]); + *cast(double*)(_retArea.ptr + 88) = cast(double)(_payload5962[2]); + } else { + *cast(ubyte*)(_retArea.ptr + 64) = cast(ubyte)(0); + } + *cast(uint*)(_retArea.ptr + 96) = cast(uint)(cast(uint)(_payload5958.particle)); + *cast(size_t*)(_retArea.ptr + (96+2*size_t.sizeof)) = cast(size_t)(_payload5958.sound.length); + *cast(void**)(_retArea.ptr + (96+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5958.sound.ptr)); + *cast(uint*)(_retArea.ptr + (96+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5958.blockParticlesPoolSize)); + break; + } + case _Tag6350.cGameEvent: { + ref wit.pumpkin.plugin.java_packets.common.CGameEvent _payload5964 = _payload5597.getCGameEvent(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(66); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload5964.event)); + *cast(float*)(_retArea.ptr + 36) = cast(float)(_payload5964.value); + break; + } + case _Tag6350.cGameRuleValues: { + ref wit.pumpkin.plugin.java_packets.common.CGameRuleValues _payload5966 = _payload5597.getCGameRuleValues(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(67); + auto _listSrc5968 = _payload5966.rules; + auto _list5968 = _listSrc5968.length ? wit.common.malloc(_listSrc5968.length * ((4*size_t.sizeof))) : null; + assert(!_listSrc5968.length || _list5968); + foreach (_elem5967_idx, ref _elem5967; _listSrc5968) { + auto _base5967 = _list5968 + _elem5967_idx * ((4*size_t.sizeof)); + *cast(size_t*)(_base5967 + size_t.sizeof) = cast(size_t)(_elem5967[0].length); + *cast(void**)(_base5967 + 0) = cast(void*)(cast(void*)(_elem5967[0].ptr)); + *cast(size_t*)(_base5967 + (3*size_t.sizeof)) = cast(size_t)(_elem5967[1].length); + *cast(void**)(_base5967 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem5967[1].ptr)); + + } + if (_listSrc5968.length) wit.common.free(_listSrc5968.ptr); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5966.rules.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(_list5968); + break; + } + case _Tag6350.cGameTestHighlightPos: { + ref wit.pumpkin.plugin.java_packets.common.CGameTestHighlightPos _payload5970 = _payload5597.getCGameTestHighlightPos(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(68); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5970.pos[0])); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5970.pos[1])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5970.pos[2])); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload5970.color)); + *cast(size_t*)(_retArea.ptr + (48+1*size_t.sizeof)) = cast(size_t)(_payload5970.label.length); + *cast(void**)(_retArea.ptr + 48) = cast(void*)(cast(void*)(_payload5970.label.ptr)); + *cast(uint*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5970.durationMs)); + break; + } + case _Tag6350.cHeadRot: { + ref wit.pumpkin.plugin.java_packets.common.CHeadRot _payload5972 = _payload5597.getCHeadRot(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(69); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5972.entityId)); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(cast(uint)(_payload5972.headYaw)); + break; + } + case _Tag6350.cHurtAnimation: { + ref wit.pumpkin.plugin.java_packets.common.CHurtAnimation _payload5974 = _payload5597.getCHurtAnimation(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(70); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5974.entityId)); + *cast(float*)(_retArea.ptr + 36) = cast(float)(_payload5974.yaw); + break; + } + case _Tag6350.cInitializeWorldBorder: { + ref wit.pumpkin.plugin.java_packets.common.CInitializeWorldBorder _payload5976 = _payload5597.getCInitializeWorldBorder(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(71); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload5976.x); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload5976.z); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload5976.oldDiameter); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload5976.newDiameter); + *cast(ulong*)(_retArea.ptr + 64) = cast(ulong)(cast(ulong)(_payload5976.speed)); + *cast(uint*)(_retArea.ptr + 72) = cast(uint)(cast(uint)(_payload5976.portalTeleportBoundary)); + *cast(uint*)(_retArea.ptr + 76) = cast(uint)(cast(uint)(_payload5976.warningBlocks)); + *cast(uint*)(_retArea.ptr + 80) = cast(uint)(cast(uint)(_payload5976.warningTime)); + break; + } + case _Tag6350.cItemCooldown: { + ref wit.pumpkin.plugin.java_packets.common.CItemCooldown _payload5978 = _payload5597.getCItemCooldown(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(72); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload5978.group.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload5978.group.ptr)); + *cast(uint*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5978.cooldown)); + break; + } + case _Tag6350.cKeepAlive: { + ref wit.pumpkin.plugin.java_packets.common.CKeepAlive _payload5980 = _payload5597.getCKeepAlive(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(73); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload5980.keepAliveId)); + break; + } + case _Tag6350.cLevelEvent: { + ref wit.pumpkin.plugin.java_packets.common.CLevelEvent _payload5982 = _payload5597.getCLevelEvent(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(74); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5982.event)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5982.location[0])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload5982.location[1])); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload5982.location[2])); + *cast(uint*)(_retArea.ptr + 48) = cast(uint)(cast(uint)(_payload5982.data)); + *cast(ubyte*)(_retArea.ptr + 52) = cast(ubyte)(cast(uint)(_payload5982.disableRelativeVolume)); + break; + } + case _Tag6350.cLightUpdate: { + ref wit.pumpkin.plugin.java_packets.common.CLightUpdate _payload5984 = _payload5597.getCLightUpdate(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(75); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5984.chunkX)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload5984.chunkZ)); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(cast(uint)(_payload5984.lightData.trustEdges)); + *cast(size_t*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(size_t)(_payload5984.lightData.skyLightMask.length); + *cast(void**)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5984.lightData.skyLightMask.ptr)); + *cast(size_t*)(_retArea.ptr + (40+4*size_t.sizeof)) = cast(size_t)(_payload5984.lightData.blockLightMask.length); + *cast(void**)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5984.lightData.blockLightMask.ptr)); + *cast(size_t*)(_retArea.ptr + (40+6*size_t.sizeof)) = cast(size_t)(_payload5984.lightData.emptySkyLightMask.length); + *cast(void**)(_retArea.ptr + (40+5*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5984.lightData.emptySkyLightMask.ptr)); + *cast(size_t*)(_retArea.ptr + (40+8*size_t.sizeof)) = cast(size_t)(_payload5984.lightData.emptyBlockLightMask.length); + *cast(void**)(_retArea.ptr + (40+7*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5984.lightData.emptyBlockLightMask.ptr)); + auto _listSrc5986 = _payload5984.lightData.skyLightArrays; + auto _list5986 = _listSrc5986.length ? wit.common.malloc(_listSrc5986.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5986.length || _list5986); + foreach (_elem5985_idx, ref _elem5985; _listSrc5986) { + auto _base5985 = _list5986 + _elem5985_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5985 + size_t.sizeof) = cast(size_t)(_elem5985.length); + *cast(void**)(_base5985 + 0) = cast(void*)(cast(void*)(_elem5985.ptr)); + + } + if (_listSrc5986.length) wit.common.free(_listSrc5986.ptr); + *cast(size_t*)(_retArea.ptr + (40+10*size_t.sizeof)) = cast(size_t)(_payload5984.lightData.skyLightArrays.length); + *cast(void**)(_retArea.ptr + (40+9*size_t.sizeof)) = cast(void*)(_list5986); + auto _listSrc5988 = _payload5984.lightData.blockLightArrays; + auto _list5988 = _listSrc5988.length ? wit.common.malloc(_listSrc5988.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5988.length || _list5988); + foreach (_elem5987_idx, ref _elem5987; _listSrc5988) { + auto _base5987 = _list5988 + _elem5987_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5987 + size_t.sizeof) = cast(size_t)(_elem5987.length); + *cast(void**)(_base5987 + 0) = cast(void*)(cast(void*)(_elem5987.ptr)); + + } + if (_listSrc5988.length) wit.common.free(_listSrc5988.ptr); + *cast(size_t*)(_retArea.ptr + (40+12*size_t.sizeof)) = cast(size_t)(_payload5984.lightData.blockLightArrays.length); + *cast(void**)(_retArea.ptr + (40+11*size_t.sizeof)) = cast(void*)(_list5988); + break; + } + case _Tag6350.cLogin: { + ref wit.pumpkin.plugin.java_packets.common.CLogin _payload5990 = _payload5597.getCLogin(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(76); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload5990.entityId)); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(cast(uint)(_payload5990.isHardcore)); + auto _listSrc5992 = _payload5990.dimensionNames; + auto _list5992 = _listSrc5992.length ? wit.common.malloc(_listSrc5992.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc5992.length || _list5992); + foreach (_elem5991_idx, ref _elem5991; _listSrc5992) { + auto _base5991 = _list5992 + _elem5991_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base5991 + size_t.sizeof) = cast(size_t)(_elem5991.length); + *cast(void**)(_base5991 + 0) = cast(void*)(cast(void*)(_elem5991.ptr)); + + } + if (_listSrc5992.length) wit.common.free(_listSrc5992.ptr); + *cast(size_t*)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(size_t)(_payload5990.dimensionNames.length); + *cast(void**)(_retArea.ptr + 40) = cast(void*)(_list5992); + *cast(uint*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5990.maxPlayers)); + *cast(uint*)(_retArea.ptr + (44+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5990.viewDistance)); + *cast(uint*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5990.simulatedDistance)); + *cast(ubyte*)(_retArea.ptr + (52+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5990.reducedDebugInfo)); + *cast(ubyte*)(_retArea.ptr + (53+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5990.enabledRespawnScreen)); + *cast(ubyte*)(_retArea.ptr + (54+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5990.limitedCrafting)); + *cast(size_t*)(_retArea.ptr + (56+3*size_t.sizeof)) = cast(size_t)(_payload5990.spawnData.dimension.length); + *cast(void**)(_retArea.ptr + (56+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5990.spawnData.dimension.ptr)); + *cast(ulong*)(_retArea.ptr + (56+4*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload5990.spawnData.hashedSeed)); + *cast(ubyte*)(_retArea.ptr + (64+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5990.spawnData.gameMode)); + *cast(ubyte*)(_retArea.ptr + (65+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5990.spawnData.previousGamemode)); + *cast(ubyte*)(_retArea.ptr + (66+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5990.spawnData.debug_)); + *cast(ubyte*)(_retArea.ptr + (67+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5990.spawnData.isFlat)); + if (_payload5990.spawnData.deathDimensionName.isSome) { + ref _payload5996 = _payload5990.spawnData.deathDimensionName.unwrap(); + *cast(ubyte*)(_retArea.ptr + (64+5*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (64+7*size_t.sizeof)) = cast(size_t)(_payload5996[0].length); + *cast(void**)(_retArea.ptr + (64+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5996[0].ptr)); + *cast(uint*)(_retArea.ptr + (64+8*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5996[1][0])); + *cast(uint*)(_retArea.ptr + (68+8*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5996[1][1])); + *cast(uint*)(_retArea.ptr + (72+8*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5996[1][2])); + } else { + *cast(ubyte*)(_retArea.ptr + (64+5*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(uint*)(_retArea.ptr + (72+9*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5990.spawnData.portalCooldown)); + *cast(uint*)(_retArea.ptr + (76+9*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5990.spawnData.sealevel)); + *cast(ubyte*)(_retArea.ptr + (88+8*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5990.onlineMode)); + *cast(ubyte*)(_retArea.ptr + (89+8*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5990.enforceSecureChat)); + break; + } + case _Tag6350.cLowDiskSpaceWarning: { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(77); + break; + } + case _Tag6350.cMapItemData: { + ref wit.pumpkin.plugin.java_packets.common.CMapItemData _payload6000 = _payload5597.getCMapItemData(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(78); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6000.mapId)); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(cast(uint)(_payload6000.scale)); + *cast(ubyte*)(_retArea.ptr + 37) = cast(ubyte)(cast(uint)(_payload6000.trackingPosition)); + *cast(ubyte*)(_retArea.ptr + 38) = cast(ubyte)(cast(uint)(_payload6000.locked)); + if (_payload6000.icons.isSome) { + ref _payload6004 = _payload6000.icons.unwrap(); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(1); + auto _listSrc6010 = _payload6004; + auto _list6010 = _listSrc6010.length ? wit.common.malloc(_listSrc6010.length * ((8+3*size_t.sizeof))) : null; + assert(!_listSrc6010.length || _list6010); + foreach (_elem6005_idx, ref _elem6005; _listSrc6010) { + auto _base6005 = _list6010 + _elem6005_idx * ((8+3*size_t.sizeof)); + *cast(uint*)(_base6005 + 0) = cast(uint)(cast(uint)(_elem6005.iconType)); + *cast(ubyte*)(_base6005 + 4) = cast(ubyte)(cast(uint)(_elem6005.x)); + *cast(ubyte*)(_base6005 + 5) = cast(ubyte)(cast(uint)(_elem6005.z)); + *cast(ubyte*)(_base6005 + 6) = cast(ubyte)(cast(uint)(_elem6005.direction)); + if (_elem6005.displayName.isSome) { + ref _payload6009 = _elem6005.displayName.unwrap(); + *cast(ubyte*)(_base6005 + 8) = cast(ubyte)(1); + *cast(size_t*)(_base6005 + (8+2*size_t.sizeof)) = cast(size_t)(_payload6009.length); + *cast(void**)(_base6005 + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6009.ptr)); + } else { + *cast(ubyte*)(_base6005 + 8) = cast(ubyte)(0); + } + + } + if (_listSrc6010.length) wit.common.free(_listSrc6010.ptr); + *cast(size_t*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(size_t)(_payload6004.length); + *cast(void**)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(void*)(_list6010); + } else { + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(0); + } + if (_payload6000.data.isSome) { + ref _payload6014 = _payload6000.data.unwrap(); + *cast(ubyte*)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(ubyte)(1); + *cast(ubyte*)(_retArea.ptr + (40+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6014.columns)); + *cast(ubyte*)(_retArea.ptr + (41+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6014.rows)); + *cast(ubyte*)(_retArea.ptr + (42+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6014.x)); + *cast(ubyte*)(_retArea.ptr + (43+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6014.z)); + *cast(size_t*)(_retArea.ptr + (40+6*size_t.sizeof)) = cast(size_t)(_payload6014.data.length); + *cast(void**)(_retArea.ptr + (40+5*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6014.data.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag6350.cMerchantOffers: { + ref wit.pumpkin.plugin.java_packets.common.CMerchantOffers _payload6016 = _payload5597.getCMerchantOffers(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(79); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6016.windowId)); + auto _listSrc6022 = _payload6016.offers; + auto _list6022 = _listSrc6022.length ? wit.common.malloc(_listSrc6022.length * ((24+8*size_t.sizeof))) : null; + assert(!_listSrc6022.length || _list6022); + foreach (_elem6017_idx, ref _elem6017; _listSrc6022) { + auto _base6017 = _list6022 + _elem6017_idx * ((24+8*size_t.sizeof)); + *cast(size_t*)(_base6017 + size_t.sizeof) = cast(size_t)(_elem6017.baseCostA.length); + *cast(void**)(_base6017 + 0) = cast(void*)(cast(void*)(_elem6017.baseCostA.ptr)); + *cast(size_t*)(_base6017 + (3*size_t.sizeof)) = cast(size_t)(_elem6017.output.length); + *cast(void**)(_base6017 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6017.output.ptr)); + if (_elem6017.costB.isSome) { + ref _payload6021 = _elem6017.costB.unwrap(); + *cast(ubyte*)(_base6017 + (4*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_base6017 + (6*size_t.sizeof)) = cast(size_t)(_payload6021.length); + *cast(void**)(_base6017 + (5*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6021.ptr)); + } else { + *cast(ubyte*)(_base6017 + (4*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_base6017 + (7*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6017.rewardExp)); + *cast(uint*)(_base6017 + (4+7*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6017.uses)); + *cast(uint*)(_base6017 + (8+7*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6017.maxUses)); + *cast(uint*)(_base6017 + (12+7*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6017.xp)); + *cast(uint*)(_base6017 + (16+7*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6017.specialPrice)); + *cast(float*)(_base6017 + (20+7*size_t.sizeof)) = cast(float)(_elem6017.priceMultiplier); + *cast(uint*)(_base6017 + (24+7*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6017.demand)); + + } + if (_listSrc6022.length) wit.common.free(_listSrc6022.ptr); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload6016.offers.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(_list6022); + *cast(uint*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6016.villagerLevel)); + *cast(uint*)(_retArea.ptr + (36+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6016.experience)); + *cast(ubyte*)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6016.isRegularVillager)); + *cast(ubyte*)(_retArea.ptr + (41+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6016.canRestock)); + break; + } + case _Tag6350.cMoveMinecartAlongTrack: { + ref wit.pumpkin.plugin.java_packets.common.CMoveMinecartAlongTrack _payload6024 = _payload5597.getCMoveMinecartAlongTrack(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(80); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6024.entityId)); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload6024.steps.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6024.steps.ptr)); + break; + } + case _Tag6350.cMoveVehicle: { + ref wit.pumpkin.plugin.java_packets.common.CMoveVehicle _payload6026 = _payload5597.getCMoveVehicle(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(81); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload6026.x); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload6026.y); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload6026.z); + *cast(float*)(_retArea.ptr + 56) = cast(float)(_payload6026.yaw); + *cast(float*)(_retArea.ptr + 60) = cast(float)(_payload6026.pitch); + break; + } + case _Tag6350.cMultiBlockUpdate: { + ref wit.pumpkin.plugin.java_packets.common.CMultiBlockUpdate _payload6028 = _payload5597.getCMultiBlockUpdate(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(82); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload6028.chunkSection[0]); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload6028.chunkSection[1]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload6028.chunkSection[2]); + *cast(ubyte*)(_retArea.ptr + 56) = cast(ubyte)(cast(uint)(_payload6028.suppressLightUpdates)); + auto _listSrc6030 = _payload6028.updates; + auto _list6030 = _listSrc6030.length ? wit.common.malloc(_listSrc6030.length * ((8+3*size_t.sizeof))) : null; + assert(!_listSrc6030.length || _list6030); + foreach (_elem6029_idx, ref _elem6029; _listSrc6030) { + auto _base6029 = _list6030 + _elem6029_idx * ((8+3*size_t.sizeof)); + *cast(uint*)(_base6029 + 0) = cast(uint)(cast(uint)(_elem6029[0][0])); + *cast(uint*)(_base6029 + 4) = cast(uint)(cast(uint)(_elem6029[0][1])); + *cast(uint*)(_base6029 + 8) = cast(uint)(cast(uint)(_elem6029[0][2])); + *cast(size_t*)(_base6029 + (8+2*size_t.sizeof)) = cast(size_t)(_elem6029[1].length); + *cast(void**)(_base6029 + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6029[1].ptr)); + + } + if (_listSrc6030.length) wit.common.free(_listSrc6030.ptr); + *cast(size_t*)(_retArea.ptr + (56+2*size_t.sizeof)) = cast(size_t)(_payload6028.updates.length); + *cast(void**)(_retArea.ptr + (56+1*size_t.sizeof)) = cast(void*)(_list6030); + break; + } + case _Tag6350.cOpenBook: { + ref wit.pumpkin.plugin.java_packets.common.COpenBook _payload6032 = _payload5597.getCOpenBook(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(83); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6032.hand)); + break; + } + case _Tag6350.cOpenMountScreen: { + ref wit.pumpkin.plugin.java_packets.common.COpenMountScreen _payload6034 = _payload5597.getCOpenMountScreen(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(84); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6034.windowId)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6034.slotCount)); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload6034.entityId)); + break; + } + case _Tag6350.cOpenScreen: { + ref wit.pumpkin.plugin.java_packets.common.COpenScreen _payload6036 = _payload5597.getCOpenScreen(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(85); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6036.syncId)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6036.windowType)); + *cast(size_t*)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(size_t)(_payload6036.windowTitle.length); + *cast(void**)(_retArea.ptr + 40) = cast(void*)(cast(void*)(_payload6036.windowTitle.ptr)); + break; + } + case _Tag6350.cOpenSignEditor: { + ref wit.pumpkin.plugin.java_packets.common.COpenSignEditor _payload6038 = _payload5597.getCOpenSignEditor(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(86); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6038.location[0])); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6038.location[1])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload6038.location[2])); + *cast(ubyte*)(_retArea.ptr + 44) = cast(ubyte)(cast(uint)(_payload6038.isFrontText)); + break; + } + case _Tag6350.cParticle: { + ref wit.pumpkin.plugin.java_packets.common.CParticle _payload6040 = _payload5597.getCParticle(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(87); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6040.forceSpawn)); + *cast(ubyte*)(_retArea.ptr + 33) = cast(ubyte)(cast(uint)(_payload6040.important)); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload6040.position[0]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload6040.position[1]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload6040.position[2]); + *cast(double*)(_retArea.ptr + 64) = cast(double)(_payload6040.offset[0]); + *cast(double*)(_retArea.ptr + 72) = cast(double)(_payload6040.offset[1]); + *cast(double*)(_retArea.ptr + 80) = cast(double)(_payload6040.offset[2]); + *cast(float*)(_retArea.ptr + 88) = cast(float)(_payload6040.maxSpeed); + *cast(uint*)(_retArea.ptr + 92) = cast(uint)(cast(uint)(_payload6040.particleCount)); + *cast(uint*)(_retArea.ptr + 96) = cast(uint)(cast(uint)(_payload6040.particleId)); + *cast(size_t*)(_retArea.ptr + (96+2*size_t.sizeof)) = cast(size_t)(_payload6040.data.length); + *cast(void**)(_retArea.ptr + (96+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6040.data.ptr)); + break; + } + case _Tag6350.cPlayPing: { + ref wit.pumpkin.plugin.java_packets.common.CPlayPing _payload6042 = _payload5597.getCPlayPing(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(88); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6042.id)); + break; + } + case _Tag6350.cPingResponse: { + ref wit.pumpkin.plugin.java_packets.common.CPingResponse _payload6044 = _payload5597.getCPingResponse(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(89); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload6044.payload)); + break; + } + case _Tag6350.cPlaceGhostRecipe: { + ref wit.pumpkin.plugin.java_packets.common.CPlaceGhostRecipe _payload6046 = _payload5597.getCPlaceGhostRecipe(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(90); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6046.windowId)); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload6046.recipeId.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6046.recipeId.ptr)); + break; + } + case _Tag6350.cPlayerAbilities: { + ref wit.pumpkin.plugin.java_packets.common.CPlayerAbilities _payload6048 = _payload5597.getCPlayerAbilities(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(91); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6048.flags)); + *cast(float*)(_retArea.ptr + 36) = cast(float)(_payload6048.flyingSpeed); + *cast(float*)(_retArea.ptr + 40) = cast(float)(_payload6048.fieldOfView); + break; + } + case _Tag6350.cPlayerChatMessage: { + ref wit.pumpkin.plugin.java_packets.common.CPlayerChatMessage _payload6050 = _payload5597.getCPlayerChatMessage(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(92); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6050.globalIndex)); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(_payload6050.sender.high); + *cast(ulong*)(_retArea.ptr + 48) = cast(ulong)(_payload6050.sender.low); + *cast(uint*)(_retArea.ptr + 56) = cast(uint)(cast(uint)(_payload6050.index)); + if (_payload6050.messageSignature.isSome) { + ref _payload6054 = _payload6050.messageSignature.unwrap(); + *cast(ubyte*)(_retArea.ptr + (56+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (56+3*size_t.sizeof)) = cast(size_t)(_payload6054.length); + *cast(void**)(_retArea.ptr + (56+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6054.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (56+1*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(size_t*)(_retArea.ptr + (56+5*size_t.sizeof)) = cast(size_t)(_payload6050.message.length); + *cast(void**)(_retArea.ptr + (56+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6050.message.ptr)); + *cast(ulong*)(_retArea.ptr + (56+6*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload6050.timestamp)); + *cast(ulong*)(_retArea.ptr + (64+6*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload6050.salt)); + auto _listSrc6060 = _payload6050.previousMessages; + auto _list6060 = _listSrc6060.length ? wit.common.malloc(_listSrc6060.length * ((4*size_t.sizeof))) : null; + assert(!_listSrc6060.length || _list6060); + foreach (_elem6055_idx, ref _elem6055; _listSrc6060) { + auto _base6055 = _list6060 + _elem6055_idx * ((4*size_t.sizeof)); + *cast(uint*)(_base6055 + 0) = cast(uint)(cast(uint)(_elem6055.id)); + if (_elem6055.signature.isSome) { + ref _payload6059 = _elem6055.signature.unwrap(); + *cast(ubyte*)(_base6055 + size_t.sizeof) = cast(ubyte)(1); + *cast(size_t*)(_base6055 + (3*size_t.sizeof)) = cast(size_t)(_payload6059.length); + *cast(void**)(_base6055 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6059.ptr)); + } else { + *cast(ubyte*)(_base6055 + size_t.sizeof) = cast(ubyte)(0); + } + + } + if (_listSrc6060.length) wit.common.free(_listSrc6060.ptr); + *cast(size_t*)(_retArea.ptr + (72+7*size_t.sizeof)) = cast(size_t)(_payload6050.previousMessages.length); + *cast(void**)(_retArea.ptr + (72+6*size_t.sizeof)) = cast(void*)(_list6060); + if (_payload6050.unsignedContent.isSome) { + ref _payload6064 = _payload6050.unsignedContent.unwrap(); + *cast(ubyte*)(_retArea.ptr + (72+8*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (72+10*size_t.sizeof)) = cast(size_t)(_payload6064.length); + *cast(void**)(_retArea.ptr + (72+9*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6064.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (72+8*size_t.sizeof)) = cast(ubyte)(0); + } + alias _Tag6071 = wit.pumpkin.plugin.java_packets.common.FilterType.Tag; + final switch (_payload6050.filterType.tag) { + case _Tag6071.passThrough: { + *cast(ubyte*)(_retArea.ptr + (72+11*size_t.sizeof)) = cast(ubyte)(0); + break; + } + case _Tag6071.fullyFiltered: { + *cast(ubyte*)(_retArea.ptr + (72+11*size_t.sizeof)) = cast(ubyte)(1); + break; + } + case _Tag6071.partiallyFiltered: { + ref WitList!(long) _payload6070 = _payload6050.filterType.getPartiallyFiltered(); + *cast(ubyte*)(_retArea.ptr + (72+11*size_t.sizeof)) = cast(ubyte)(2); + *cast(size_t*)(_retArea.ptr + (72+13*size_t.sizeof)) = cast(size_t)(_payload6070.length); + *cast(void**)(_retArea.ptr + (72+12*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6070.ptr)); + break; + } + } + *cast(uint*)(_retArea.ptr + (72+14*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6050.chatType)); + *cast(size_t*)(_retArea.ptr + (72+16*size_t.sizeof)) = cast(size_t)(_payload6050.senderName.length); + *cast(void**)(_retArea.ptr + (72+15*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6050.senderName.ptr)); + if (_payload6050.targetName.isSome) { + ref _payload6075 = _payload6050.targetName.unwrap(); + *cast(ubyte*)(_retArea.ptr + (72+17*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (72+19*size_t.sizeof)) = cast(size_t)(_payload6075.length); + *cast(void**)(_retArea.ptr + (72+18*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6075.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (72+17*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag6350.cPlayerInfoUpdate: { + ref wit.pumpkin.plugin.java_packets.common.CPlayerInfoUpdate _payload6077 = _payload5597.getCPlayerInfoUpdate(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(93); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6077.actions)); + auto _listSrc6110 = _payload6077.players; + auto _list6110 = _listSrc6110.length ? wit.common.malloc(_listSrc6110.length * ((16+2*size_t.sizeof))) : null; + assert(!_listSrc6110.length || _list6110); + foreach (_elem6078_idx, ref _elem6078; _listSrc6110) { + auto _base6078 = _list6110 + _elem6078_idx * ((16+2*size_t.sizeof)); + *cast(ulong*)(_base6078 + 0) = cast(ulong)(_elem6078.uuid.high); + *cast(ulong*)(_base6078 + 8) = cast(ulong)(_elem6078.uuid.low); + auto _listSrc6109 = _elem6078.actions; + auto _list6109 = _listSrc6109.length ? wit.common.malloc(_listSrc6109.length * ((40+4*size_t.sizeof))) : null; + assert(!_listSrc6109.length || _list6109); + foreach (_elem6079_idx, ref _elem6079; _listSrc6109) { + auto _base6079 = _list6109 + _elem6079_idx * ((40+4*size_t.sizeof)); + alias _Tag6108 = wit.pumpkin.plugin.java_packets.common.PlayerAction.Tag; + final switch (_elem6079.tag) { + case _Tag6108.addPlayer: { + ref wit.pumpkin.plugin.java_packets.common.PlayerActionAddPlayer _payload6081 = _elem6079.getAddPlayer(); + *cast(ubyte*)(_base6079 + 0) = cast(ubyte)(0); + *cast(size_t*)(_base6079 + (8+1*size_t.sizeof)) = cast(size_t)(_payload6081.name.length); + *cast(void**)(_base6079 + 8) = cast(void*)(cast(void*)(_payload6081.name.ptr)); + auto _listSrc6085 = _payload6081.properties; + auto _list6085 = _listSrc6085.length ? wit.common.malloc(_listSrc6085.length * ((16+2*size_t.sizeof))) : null; + assert(!_listSrc6085.length || _list6085); + foreach (_elem6082_idx, ref _elem6082; _listSrc6085) { + auto _base6082 = _list6085 + _elem6082_idx * ((16+2*size_t.sizeof)); + *cast(uint*)(_base6082 + 0) = cast(uint)(cast(uint)(_elem6082.id)); + *cast(double*)(_base6082 + 8) = cast(double)(_elem6082.value); + auto _listSrc6084 = _elem6082.modifiers; + auto _list6084 = _listSrc6084.length ? wit.common.malloc(_listSrc6084.length * ((16+2*size_t.sizeof))) : null; + assert(!_listSrc6084.length || _list6084); + foreach (_elem6083_idx, ref _elem6083; _listSrc6084) { + auto _base6083 = _list6084 + _elem6083_idx * ((16+2*size_t.sizeof)); + *cast(size_t*)(_base6083 + size_t.sizeof) = cast(size_t)(_elem6083.id.length); + *cast(void**)(_base6083 + 0) = cast(void*)(cast(void*)(_elem6083.id.ptr)); + *cast(double*)(_base6083 + (2*size_t.sizeof)) = cast(double)(_elem6083.amount); + *cast(ubyte*)(_base6083 + (8+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6083.operation)); + + } + if (_listSrc6084.length) wit.common.free(_listSrc6084.ptr); + *cast(size_t*)(_base6082 + (16+1*size_t.sizeof)) = cast(size_t)(_elem6082.modifiers.length); + *cast(void**)(_base6082 + 16) = cast(void*)(_list6084); + + } + if (_listSrc6085.length) wit.common.free(_listSrc6085.ptr); + *cast(size_t*)(_base6079 + (8+3*size_t.sizeof)) = cast(size_t)(_payload6081.properties.length); + *cast(void**)(_base6079 + (8+2*size_t.sizeof)) = cast(void*)(_list6085); + break; + } + case _Tag6108.initializeChat: { + ref Option!(wit.pumpkin.plugin.java_packets.common.InitChat) _payload6087 = _elem6079.getInitializeChat(); + *cast(ubyte*)(_base6079 + 0) = cast(ubyte)(1); + if (_payload6087.isSome) { + ref _payload6091 = _payload6087.unwrap(); + *cast(ubyte*)(_base6079 + 8) = cast(ubyte)(1); + *cast(ulong*)(_base6079 + 16) = cast(ulong)(_payload6091.sessionId.high); + *cast(ulong*)(_base6079 + 24) = cast(ulong)(_payload6091.sessionId.low); + *cast(ulong*)(_base6079 + 32) = cast(ulong)(cast(ulong)(_payload6091.expiresAt)); + *cast(size_t*)(_base6079 + (40+1*size_t.sizeof)) = cast(size_t)(_payload6091.publicKey.length); + *cast(void**)(_base6079 + 40) = cast(void*)(cast(void*)(_payload6091.publicKey.ptr)); + *cast(size_t*)(_base6079 + (40+3*size_t.sizeof)) = cast(size_t)(_payload6091.signature.length); + *cast(void**)(_base6079 + (40+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6091.signature.ptr)); + } else { + *cast(ubyte*)(_base6079 + 8) = cast(ubyte)(0); + } + break; + } + case _Tag6108.updateGameMode: { + ref int _payload6093 = _elem6079.getUpdateGameMode(); + *cast(ubyte*)(_base6079 + 0) = cast(ubyte)(2); + *cast(uint*)(_base6079 + 8) = cast(uint)(cast(uint)(_payload6093)); + break; + } + case _Tag6108.updateListed: { + ref bool _payload6095 = _elem6079.getUpdateListed(); + *cast(ubyte*)(_base6079 + 0) = cast(ubyte)(3); + *cast(ubyte*)(_base6079 + 8) = cast(ubyte)(cast(uint)(_payload6095)); + break; + } + case _Tag6108.updateLatency: { + ref int _payload6097 = _elem6079.getUpdateLatency(); + *cast(ubyte*)(_base6079 + 0) = cast(ubyte)(4); + *cast(uint*)(_base6079 + 8) = cast(uint)(cast(uint)(_payload6097)); + break; + } + case _Tag6108.updateDisplayName: { + ref Option!(WitString) _payload6099 = _elem6079.getUpdateDisplayName(); + *cast(ubyte*)(_base6079 + 0) = cast(ubyte)(5); + if (_payload6099.isSome) { + ref _payload6103 = _payload6099.unwrap(); + *cast(ubyte*)(_base6079 + 8) = cast(ubyte)(1); + *cast(size_t*)(_base6079 + (8+2*size_t.sizeof)) = cast(size_t)(_payload6103.length); + *cast(void**)(_base6079 + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6103.ptr)); + } else { + *cast(ubyte*)(_base6079 + 8) = cast(ubyte)(0); + } + break; + } + case _Tag6108.updateListOrder: { + ref int _payload6105 = _elem6079.getUpdateListOrder(); + *cast(ubyte*)(_base6079 + 0) = cast(ubyte)(6); + *cast(uint*)(_base6079 + 8) = cast(uint)(cast(uint)(_payload6105)); + break; + } + case _Tag6108.updateHat: { + ref bool _payload6107 = _elem6079.getUpdateHat(); + *cast(ubyte*)(_base6079 + 0) = cast(ubyte)(7); + *cast(ubyte*)(_base6079 + 8) = cast(ubyte)(cast(uint)(_payload6107)); + break; + } + } + + } + if (_listSrc6109.length) wit.common.free(_listSrc6109.ptr); + *cast(size_t*)(_base6078 + (16+1*size_t.sizeof)) = cast(size_t)(_elem6078.actions.length); + *cast(void**)(_base6078 + 16) = cast(void*)(_list6109); + + } + if (_listSrc6110.length) wit.common.free(_listSrc6110.ptr); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload6077.players.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(_list6110); + break; + } + case _Tag6350.cPlayerLookAt: { + ref wit.pumpkin.plugin.java_packets.common.CPlayerLookAt _payload6112 = _payload5597.getCPlayerLookAt(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(94); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6112.fromAnchor)); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload6112.targetX); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload6112.targetY); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload6112.targetZ); + if (_payload6112.entity.isSome) { + ref _payload6116 = _payload6112.entity.unwrap(); + *cast(ubyte*)(_retArea.ptr + 64) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 68) = cast(uint)(cast(uint)(_payload6116[0])); + *cast(uint*)(_retArea.ptr + 72) = cast(uint)(cast(uint)(_payload6116[1])); + } else { + *cast(ubyte*)(_retArea.ptr + 64) = cast(ubyte)(0); + } + break; + } + case _Tag6350.cPlayerPosition: { + ref wit.pumpkin.plugin.java_packets.common.CPlayerPosition _payload6118 = _payload5597.getCPlayerPosition(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(95); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6118.teleportId)); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload6118.position[0]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload6118.position[1]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload6118.position[2]); + *cast(double*)(_retArea.ptr + 64) = cast(double)(_payload6118.delta[0]); + *cast(double*)(_retArea.ptr + 72) = cast(double)(_payload6118.delta[1]); + *cast(double*)(_retArea.ptr + 80) = cast(double)(_payload6118.delta[2]); + *cast(float*)(_retArea.ptr + 88) = cast(float)(_payload6118.yaw); + *cast(float*)(_retArea.ptr + 92) = cast(float)(_payload6118.pitch); + auto _listSrc6120 = _payload6118.relatives; + auto _list6120 = _listSrc6120.length ? wit.common.malloc(_listSrc6120.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc6120.length || _list6120); + foreach (_elem6119_idx, ref _elem6119; _listSrc6120) { + auto _base6119 = _list6120 + _elem6119_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6119 + size_t.sizeof) = cast(size_t)(_elem6119.length); + *cast(void**)(_base6119 + 0) = cast(void*)(cast(void*)(_elem6119.ptr)); + + } + if (_listSrc6120.length) wit.common.free(_listSrc6120.ptr); + *cast(size_t*)(_retArea.ptr + (96+1*size_t.sizeof)) = cast(size_t)(_payload6118.relatives.length); + *cast(void**)(_retArea.ptr + 96) = cast(void*)(_list6120); + break; + } + case _Tag6350.cRemovePlayerInfo: { + ref wit.pumpkin.plugin.java_packets.common.CRemovePlayerInfo _payload6122 = _payload5597.getCRemovePlayerInfo(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(96); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6122.players.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6122.players.ptr)); + break; + } + case _Tag6350.cPlayerRotation: { + ref wit.pumpkin.plugin.java_packets.common.CPlayerRotation _payload6124 = _payload5597.getCPlayerRotation(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(97); + *cast(float*)(_retArea.ptr + 32) = cast(float)(_payload6124.yaw); + *cast(float*)(_retArea.ptr + 36) = cast(float)(_payload6124.pitch); + break; + } + case _Tag6350.cPlayerSpawnPosition: { + ref wit.pumpkin.plugin.java_packets.common.CPlayerSpawnPosition _payload6126 = _payload5597.getCPlayerSpawnPosition(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(98); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6126.dimensionName.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6126.dimensionName.ptr)); + *cast(uint*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6126.location[0])); + *cast(uint*)(_retArea.ptr + (36+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6126.location[1])); + *cast(uint*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6126.location[2])); + *cast(float*)(_retArea.ptr + (44+2*size_t.sizeof)) = cast(float)(_payload6126.yaw); + *cast(float*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(float)(_payload6126.pitch); + break; + } + case _Tag6350.cProjectilePower: { + ref wit.pumpkin.plugin.java_packets.common.CProjectilePower _payload6128 = _payload5597.getCProjectilePower(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(99); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6128.entityId)); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload6128.xPower); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload6128.yPower); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload6128.zPower); + break; + } + case _Tag6350.cRecipeBookAdd: { + ref wit.pumpkin.plugin.java_packets.common.CRecipeBookAdd _payload6130 = _payload5597.getCRecipeBookAdd(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(100); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6130.replace)); + break; + } + case _Tag6350.cRecipeBookRemove: { + ref wit.pumpkin.plugin.java_packets.common.CRecipeBookRemove _payload6132 = _payload5597.getCRecipeBookRemove(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(101); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6132.recipes.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6132.recipes.ptr)); + break; + } + case _Tag6350.cRecipeBookSettings: { + ref wit.pumpkin.plugin.java_packets.common.CRecipeBookSettings _payload6134 = _payload5597.getCRecipeBookSettings(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(102); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6134.craftingOpen)); + *cast(ubyte*)(_retArea.ptr + 33) = cast(ubyte)(cast(uint)(_payload6134.craftingFiltering)); + *cast(ubyte*)(_retArea.ptr + 34) = cast(ubyte)(cast(uint)(_payload6134.furnaceOpen)); + *cast(ubyte*)(_retArea.ptr + 35) = cast(ubyte)(cast(uint)(_payload6134.furnaceFiltering)); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(cast(uint)(_payload6134.blastFurnaceOpen)); + *cast(ubyte*)(_retArea.ptr + 37) = cast(ubyte)(cast(uint)(_payload6134.blastFurnaceFiltering)); + *cast(ubyte*)(_retArea.ptr + 38) = cast(ubyte)(cast(uint)(_payload6134.smokerOpen)); + *cast(ubyte*)(_retArea.ptr + 39) = cast(ubyte)(cast(uint)(_payload6134.smokerFiltering)); + break; + } + case _Tag6350.cRemoveEntities: { + ref wit.pumpkin.plugin.java_packets.common.CRemoveEntities _payload6136 = _payload5597.getCRemoveEntities(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(103); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6136.entityIds.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6136.entityIds.ptr)); + break; + } + case _Tag6350.cRemoveMobEffect: { + ref wit.pumpkin.plugin.java_packets.common.CRemoveMobEffect _payload6138 = _payload5597.getCRemoveMobEffect(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(104); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6138.entityId)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6138.effectId)); + break; + } + case _Tag6350.cRemoveResourcePack: { + ref wit.pumpkin.plugin.java_packets.common.CRemoveResourcePack _payload6140 = _payload5597.getCRemoveResourcePack(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(105); + if (_payload6140.uuid.isSome) { + ref _payload6144 = _payload6140.uuid.unwrap(); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(1); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(_payload6144.high); + *cast(ulong*)(_retArea.ptr + 48) = cast(ulong)(_payload6144.low); + } else { + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(0); + } + break; + } + case _Tag6350.cResetScore: { + ref wit.pumpkin.plugin.java_packets.common.CResetScore _payload6146 = _payload5597.getCResetScore(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(106); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6146.entityName.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6146.entityName.ptr)); + if (_payload6146.objectiveName.isSome) { + ref _payload6150 = _payload6146.objectiveName.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(size_t)(_payload6150.length); + *cast(void**)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6150.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag6350.cRespawn: { + ref wit.pumpkin.plugin.java_packets.common.CRespawn _payload6152 = _payload5597.getCRespawn(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(107); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6152.playerSpawnInfo.dimension.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6152.playerSpawnInfo.dimension.ptr)); + *cast(ulong*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload6152.playerSpawnInfo.hashedSeed)); + *cast(ubyte*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6152.playerSpawnInfo.gameMode)); + *cast(ubyte*)(_retArea.ptr + (41+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6152.playerSpawnInfo.previousGamemode)); + *cast(ubyte*)(_retArea.ptr + (42+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6152.playerSpawnInfo.debug_)); + *cast(ubyte*)(_retArea.ptr + (43+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6152.playerSpawnInfo.isFlat)); + if (_payload6152.playerSpawnInfo.deathDimensionName.isSome) { + ref _payload6156 = _payload6152.playerSpawnInfo.deathDimensionName.unwrap(); + *cast(ubyte*)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (40+5*size_t.sizeof)) = cast(size_t)(_payload6156[0].length); + *cast(void**)(_retArea.ptr + (40+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6156[0].ptr)); + *cast(uint*)(_retArea.ptr + (40+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6156[1][0])); + *cast(uint*)(_retArea.ptr + (44+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6156[1][1])); + *cast(uint*)(_retArea.ptr + (48+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6156[1][2])); + } else { + *cast(ubyte*)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(uint*)(_retArea.ptr + (48+7*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6152.playerSpawnInfo.portalCooldown)); + *cast(uint*)(_retArea.ptr + (52+7*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6152.playerSpawnInfo.sealevel)); + *cast(ubyte*)(_retArea.ptr + (64+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6152.dataKept)); + break; + } + case _Tag6350.cSelectAdvancementsTab: { + ref wit.pumpkin.plugin.java_packets.common.CSelectAdvancementsTab _payload6158 = _payload5597.getCSelectAdvancementsTab(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(108); + if (_payload6158.tabId.isSome) { + ref _payload6162 = _payload6158.tabId.unwrap(); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload6162.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6162.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(0); + } + break; + } + case _Tag6350.cServerData: { + ref wit.pumpkin.plugin.java_packets.common.CServerData _payload6164 = _payload5597.getCServerData(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(109); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6164.motd.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6164.motd.ptr)); + if (_payload6164.iconBase64.isSome) { + ref _payload6168 = _payload6164.iconBase64.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(size_t)(_payload6168.length); + *cast(void**)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6168.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag6350.cPlayServerLinks: { + ref wit.pumpkin.plugin.java_packets.common.CPlayServerLinks _payload6170 = _payload5597.getCPlayServerLinks(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(110); + auto _listSrc6172 = _payload6170.links; + auto _list6172 = _listSrc6172.length ? wit.common.malloc(_listSrc6172.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc6172.length || _list6172); + foreach (_elem6171_idx, ref _elem6171; _listSrc6172) { + auto _base6171 = _list6172 + _elem6171_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6171 + size_t.sizeof) = cast(size_t)(_elem6171.length); + *cast(void**)(_base6171 + 0) = cast(void*)(cast(void*)(_elem6171.ptr)); + + } + if (_listSrc6172.length) wit.common.free(_listSrc6172.ptr); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6170.links.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(_list6172); + break; + } + case _Tag6350.cSetBorderCenter: { + ref wit.pumpkin.plugin.java_packets.common.CSetBorderCenter _payload6174 = _payload5597.getCSetBorderCenter(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(111); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload6174.x); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload6174.z); + break; + } + case _Tag6350.cSetBorderLerpSize: { + ref wit.pumpkin.plugin.java_packets.common.CSetBorderLerpSize _payload6176 = _payload5597.getCSetBorderLerpSize(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(112); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload6176.oldDiameter); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload6176.newDiameter); + *cast(ulong*)(_retArea.ptr + 48) = cast(ulong)(cast(ulong)(_payload6176.speed)); + break; + } + case _Tag6350.cSetBorderSize: { + ref wit.pumpkin.plugin.java_packets.common.CSetBorderSize _payload6178 = _payload5597.getCSetBorderSize(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(113); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload6178.diameter); + break; + } + case _Tag6350.cSetBorderWarningDelay: { + ref wit.pumpkin.plugin.java_packets.common.CSetBorderWarningDelay _payload6180 = _payload5597.getCSetBorderWarningDelay(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(114); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6180.warningTime)); + break; + } + case _Tag6350.cSetBorderWarningDistance: { + ref wit.pumpkin.plugin.java_packets.common.CSetBorderWarningDistance _payload6182 = _payload5597.getCSetBorderWarningDistance(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(115); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6182.warningBlocks)); + break; + } + case _Tag6350.cSetCamera: { + ref wit.pumpkin.plugin.java_packets.common.CSetCamera _payload6184 = _payload5597.getCSetCamera(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(116); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6184.cameraId)); + break; + } + case _Tag6350.cSetChunkCacheRadius: { + ref wit.pumpkin.plugin.java_packets.common.CSetChunkCacheRadius _payload6186 = _payload5597.getCSetChunkCacheRadius(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(117); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6186.radius)); + break; + } + case _Tag6350.cSetContainerContent: { + ref wit.pumpkin.plugin.java_packets.common.CSetContainerContent _payload6188 = _payload5597.getCSetContainerContent(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(118); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6188.windowId)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6188.stateId)); + auto _listSrc6190 = _payload6188.slotData; + auto _list6190 = _listSrc6190.length ? wit.common.malloc(_listSrc6190.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc6190.length || _list6190); + foreach (_elem6189_idx, ref _elem6189; _listSrc6190) { + auto _base6189 = _list6190 + _elem6189_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6189 + size_t.sizeof) = cast(size_t)(_elem6189.length); + *cast(void**)(_base6189 + 0) = cast(void*)(cast(void*)(_elem6189.ptr)); + + } + if (_listSrc6190.length) wit.common.free(_listSrc6190.ptr); + *cast(size_t*)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(size_t)(_payload6188.slotData.length); + *cast(void**)(_retArea.ptr + 40) = cast(void*)(_list6190); + *cast(size_t*)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(size_t)(_payload6188.carriedItem.length); + *cast(void**)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6188.carriedItem.ptr)); + break; + } + case _Tag6350.cSetContainerProperty: { + ref wit.pumpkin.plugin.java_packets.common.CSetContainerProperty _payload6192 = _payload5597.getCSetContainerProperty(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(119); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6192.windowId)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6192.property)); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload6192.value)); + break; + } + case _Tag6350.cSetContainerSlot: { + ref wit.pumpkin.plugin.java_packets.common.CSetContainerSlot _payload6194 = _payload5597.getCSetContainerSlot(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(120); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6194.windowId)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6194.stateId)); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload6194.slot)); + *cast(size_t*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(size_t)(_payload6194.slotData.length); + *cast(void**)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6194.slotData.ptr)); + break; + } + case _Tag6350.cSetCursorItem: { + ref wit.pumpkin.plugin.java_packets.common.CSetCursorItem _payload6196 = _payload5597.getCSetCursorItem(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(121); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6196.stack.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6196.stack.ptr)); + break; + } + case _Tag6350.cSetEntityLink: { + ref wit.pumpkin.plugin.java_packets.common.CSetEntityLink _payload6198 = _payload5597.getCSetEntityLink(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(122); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6198.attachedEntityId)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6198.holdingEntityId)); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(cast(uint)(_payload6198.leash)); + break; + } + case _Tag6350.cSetEquipment: { + ref wit.pumpkin.plugin.java_packets.common.CSetEquipment _payload6200 = _payload5597.getCSetEquipment(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(123); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6200.entityId)); + auto _listSrc6202 = _payload6200.equipment; + auto _list6202 = _listSrc6202.length ? wit.common.malloc(_listSrc6202.length * ((3*size_t.sizeof))) : null; + assert(!_listSrc6202.length || _list6202); + foreach (_elem6201_idx, ref _elem6201; _listSrc6202) { + auto _base6201 = _list6202 + _elem6201_idx * ((3*size_t.sizeof)); + *cast(ubyte*)(_base6201 + 0) = cast(ubyte)(cast(uint)(_elem6201[0])); + *cast(size_t*)(_base6201 + (2*size_t.sizeof)) = cast(size_t)(_elem6201[1].length); + *cast(void**)(_base6201 + size_t.sizeof) = cast(void*)(cast(void*)(_elem6201[1].ptr)); + + } + if (_listSrc6202.length) wit.common.free(_listSrc6202.ptr); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload6200.equipment.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(_list6202); + break; + } + case _Tag6350.cSetExperience: { + ref wit.pumpkin.plugin.java_packets.common.CSetExperience _payload6204 = _payload5597.getCSetExperience(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(124); + *cast(float*)(_retArea.ptr + 32) = cast(float)(_payload6204.progress); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6204.level)); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload6204.totalExperience)); + break; + } + case _Tag6350.cSetHealth: { + ref wit.pumpkin.plugin.java_packets.common.CSetHealth _payload6206 = _payload5597.getCSetHealth(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(125); + *cast(float*)(_retArea.ptr + 32) = cast(float)(_payload6206.health); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6206.food)); + *cast(float*)(_retArea.ptr + 40) = cast(float)(_payload6206.foodSaturation); + break; + } + case _Tag6350.cSetPassengers: { + ref wit.pumpkin.plugin.java_packets.common.CSetPassengers _payload6208 = _payload5597.getCSetPassengers(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(126); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6208.entityId)); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload6208.passengers.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6208.passengers.ptr)); + break; + } + case _Tag6350.cSetPlayerInventory: { + ref wit.pumpkin.plugin.java_packets.common.CSetPlayerInventory _payload6210 = _payload5597.getCSetPlayerInventory(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(127); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6210.slot)); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload6210.item.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6210.item.ptr)); + break; + } + case _Tag6350.cSetPlayerTeam: { + ref wit.pumpkin.plugin.java_packets.common.CSetPlayerTeam _payload6212 = _payload5597.getCSetPlayerTeam(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(128); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6212.teamName.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6212.teamName.ptr)); + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6212.method)); + if (_payload6212.parameters.isSome) { + ref _payload6216 = _payload6212.parameters.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+5*size_t.sizeof)) = cast(size_t)(_payload6216.displayName.length); + *cast(void**)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6216.displayName.ptr)); + *cast(ubyte*)(_retArea.ptr + (32+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6216.options)); + *cast(size_t*)(_retArea.ptr + (32+8*size_t.sizeof)) = cast(size_t)(_payload6216.nametagVisibility.length); + *cast(void**)(_retArea.ptr + (32+7*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6216.nametagVisibility.ptr)); + *cast(size_t*)(_retArea.ptr + (32+10*size_t.sizeof)) = cast(size_t)(_payload6216.collisionRule.length); + *cast(void**)(_retArea.ptr + (32+9*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6216.collisionRule.ptr)); + *cast(uint*)(_retArea.ptr + (32+11*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6216.color)); + *cast(size_t*)(_retArea.ptr + (32+13*size_t.sizeof)) = cast(size_t)(_payload6216.playerPrefix.length); + *cast(void**)(_retArea.ptr + (32+12*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6216.playerPrefix.ptr)); + *cast(size_t*)(_retArea.ptr + (32+15*size_t.sizeof)) = cast(size_t)(_payload6216.playerSuffix.length); + *cast(void**)(_retArea.ptr + (32+14*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6216.playerSuffix.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(ubyte)(0); + } + auto _listSrc6218 = _payload6212.players; + auto _list6218 = _listSrc6218.length ? wit.common.malloc(_listSrc6218.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc6218.length || _list6218); + foreach (_elem6217_idx, ref _elem6217; _listSrc6218) { + auto _base6217 = _list6218 + _elem6217_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6217 + size_t.sizeof) = cast(size_t)(_elem6217.length); + *cast(void**)(_base6217 + 0) = cast(void*)(cast(void*)(_elem6217.ptr)); + + } + if (_listSrc6218.length) wit.common.free(_listSrc6218.ptr); + *cast(size_t*)(_retArea.ptr + (32+17*size_t.sizeof)) = cast(size_t)(_payload6212.players.length); + *cast(void**)(_retArea.ptr + (32+16*size_t.sizeof)) = cast(void*)(_list6218); + break; + } + case _Tag6350.cSetSimulationDistance: { + ref wit.pumpkin.plugin.java_packets.common.CSetSimulationDistance _payload6220 = _payload5597.getCSetSimulationDistance(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(129); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6220.simulationDistance)); + break; + } + case _Tag6350.cUpdateTime: { + ref wit.pumpkin.plugin.java_packets.common.CUpdateTime _payload6222 = _payload5597.getCUpdateTime(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(130); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload6222.gameTime)); + *cast(size_t*)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(size_t)(_payload6222.clockUpdates.length); + *cast(void**)(_retArea.ptr + 40) = cast(void*)(cast(void*)(_payload6222.clockUpdates.ptr)); + break; + } + case _Tag6350.cTitleText: { + ref wit.pumpkin.plugin.java_packets.common.CTitleText _payload6224 = _payload5597.getCTitleText(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(131); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6224.title.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6224.title.ptr)); + break; + } + case _Tag6350.cTitleAnimation: { + ref wit.pumpkin.plugin.java_packets.common.CTitleAnimation _payload6226 = _payload5597.getCTitleAnimation(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(132); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6226.fadeInTicks)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6226.stayTicks)); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload6226.fadeOutTicks)); + break; + } + case _Tag6350.cPlayShowDialog: { + ref wit.pumpkin.plugin.java_packets.common.CPlayShowDialog _payload6228 = _payload5597.getCPlayShowDialog(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(133); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6228.dialog.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6228.dialog.ptr)); + break; + } + case _Tag6350.cSoundEffect: { + ref wit.pumpkin.plugin.java_packets.common.CSoundEffect _payload6230 = _payload5597.getCSoundEffect(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(134); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6230.soundEvent.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6230.soundEvent.ptr)); + *cast(uint*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6230.soundCategory)); + *cast(double*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(double)(_payload6230.position[0]); + *cast(double*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(double)(_payload6230.position[1]); + *cast(double*)(_retArea.ptr + (56+2*size_t.sizeof)) = cast(double)(_payload6230.position[2]); + *cast(float*)(_retArea.ptr + (64+2*size_t.sizeof)) = cast(float)(_payload6230.volume); + *cast(float*)(_retArea.ptr + (68+2*size_t.sizeof)) = cast(float)(_payload6230.pitch); + *cast(double*)(_retArea.ptr + (72+2*size_t.sizeof)) = cast(double)(_payload6230.seed); + break; + } + case _Tag6350.cSpawnEntity: { + ref wit.pumpkin.plugin.java_packets.common.CSpawnEntity _payload6232 = _payload5597.getCSpawnEntity(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(135); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6232.entityId)); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(_payload6232.entityUuid.high); + *cast(ulong*)(_retArea.ptr + 48) = cast(ulong)(_payload6232.entityUuid.low); + *cast(uint*)(_retArea.ptr + 56) = cast(uint)(cast(uint)(_payload6232.rType)); + *cast(double*)(_retArea.ptr + 64) = cast(double)(_payload6232.position[0]); + *cast(double*)(_retArea.ptr + 72) = cast(double)(_payload6232.position[1]); + *cast(double*)(_retArea.ptr + 80) = cast(double)(_payload6232.position[2]); + *cast(size_t*)(_retArea.ptr + (88+1*size_t.sizeof)) = cast(size_t)(_payload6232.velocity.length); + *cast(void**)(_retArea.ptr + 88) = cast(void*)(cast(void*)(_payload6232.velocity.ptr)); + *cast(ubyte*)(_retArea.ptr + (88+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6232.pitch)); + *cast(ubyte*)(_retArea.ptr + (89+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6232.yaw)); + *cast(ubyte*)(_retArea.ptr + (90+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6232.headYaw)); + *cast(uint*)(_retArea.ptr + (92+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6232.data)); + break; + } + case _Tag6350.cSpawnLivingEntity: { + ref wit.pumpkin.plugin.java_packets.common.CSpawnLivingEntity _payload6234 = _payload5597.getCSpawnLivingEntity(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(136); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6234.entityId)); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(_payload6234.entityUuid.high); + *cast(ulong*)(_retArea.ptr + 48) = cast(ulong)(_payload6234.entityUuid.low); + *cast(uint*)(_retArea.ptr + 56) = cast(uint)(cast(uint)(_payload6234.rType)); + *cast(double*)(_retArea.ptr + 64) = cast(double)(_payload6234.position[0]); + *cast(double*)(_retArea.ptr + 72) = cast(double)(_payload6234.position[1]); + *cast(double*)(_retArea.ptr + 80) = cast(double)(_payload6234.position[2]); + *cast(ubyte*)(_retArea.ptr + 88) = cast(ubyte)(cast(uint)(_payload6234.yaw)); + *cast(ubyte*)(_retArea.ptr + 89) = cast(ubyte)(cast(uint)(_payload6234.pitch)); + *cast(ubyte*)(_retArea.ptr + 90) = cast(ubyte)(cast(uint)(_payload6234.headYaw)); + *cast(size_t*)(_retArea.ptr + (88+2*size_t.sizeof)) = cast(size_t)(_payload6234.velocity.length); + *cast(void**)(_retArea.ptr + (88+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6234.velocity.ptr)); + if (_payload6234.metadata.isSome) { + ref _payload6238 = _payload6234.metadata.unwrap(); + *cast(ubyte*)(_retArea.ptr + (88+3*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (88+5*size_t.sizeof)) = cast(size_t)(_payload6238.length); + *cast(void**)(_retArea.ptr + (88+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6238.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (88+3*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag6350.cSpawnPainting: { + ref wit.pumpkin.plugin.java_packets.common.CSpawnPainting _payload6240 = _payload5597.getCSpawnPainting(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(137); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6240.entityId)); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(_payload6240.uuid.high); + *cast(ulong*)(_retArea.ptr + 48) = cast(ulong)(_payload6240.uuid.low); + *cast(size_t*)(_retArea.ptr + (56+1*size_t.sizeof)) = cast(size_t)(_payload6240.title.length); + *cast(void**)(_retArea.ptr + 56) = cast(void*)(cast(void*)(_payload6240.title.ptr)); + *cast(uint*)(_retArea.ptr + (56+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6240.variant)); + *cast(uint*)(_retArea.ptr + (60+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6240.location[0])); + *cast(uint*)(_retArea.ptr + (64+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6240.location[1])); + *cast(uint*)(_retArea.ptr + (68+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6240.location[2])); + *cast(ubyte*)(_retArea.ptr + (72+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6240.direction)); + break; + } + case _Tag6350.cStartConfiguration: { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(138); + break; + } + case _Tag6350.cStopSound: { + ref wit.pumpkin.plugin.java_packets.common.CStopSound _payload6244 = _payload5597.getCStopSound(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(139); + if (_payload6244.soundId.isSome) { + ref _payload6248 = _payload6244.soundId.unwrap(); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload6248.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6248.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(0); + } + if (_payload6244.category.isSome) { + ref _payload6252 = _payload6244.category.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+5*size_t.sizeof)) = cast(size_t)(_payload6252.length); + *cast(void**)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6252.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag6350.cStoreCookie: { + ref wit.pumpkin.plugin.java_packets.common.CStoreCookie _payload6254 = _payload5597.getCStoreCookie(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(140); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6254.key.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6254.key.ptr)); + *cast(size_t*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(size_t)(_payload6254.payload.length); + *cast(void**)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6254.payload.ptr)); + break; + } + case _Tag6350.cSubtitle: { + ref wit.pumpkin.plugin.java_packets.common.CSubtitle _payload6256 = _payload5597.getCSubtitle(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(141); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6256.subtitle.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6256.subtitle.ptr)); + break; + } + case _Tag6350.cTabList: { + ref wit.pumpkin.plugin.java_packets.common.CTabList _payload6258 = _payload5597.getCTabList(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(142); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6258.header.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6258.header.ptr)); + *cast(size_t*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(size_t)(_payload6258.footer.length); + *cast(void**)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6258.footer.ptr)); + break; + } + case _Tag6350.cTagQueryResponse: { + ref wit.pumpkin.plugin.java_packets.common.CTagQueryResponse _payload6260 = _payload5597.getCTagQueryResponse(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(143); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6260.transactionId)); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload6260.nbtBytes.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6260.nbtBytes.ptr)); + break; + } + case _Tag6350.cTakeItemEntity: { + ref wit.pumpkin.plugin.java_packets.common.CTakeItemEntity _payload6262 = _payload5597.getCTakeItemEntity(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(144); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6262.entityId)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6262.collectorEntityId)); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload6262.stackAmount)); + break; + } + case _Tag6350.cTeleportEntity: { + ref wit.pumpkin.plugin.java_packets.common.CTeleportEntity _payload6264 = _payload5597.getCTeleportEntity(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(145); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6264.entityId)); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload6264.position[0]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload6264.position[1]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload6264.position[2]); + *cast(double*)(_retArea.ptr + 64) = cast(double)(_payload6264.delta[0]); + *cast(double*)(_retArea.ptr + 72) = cast(double)(_payload6264.delta[1]); + *cast(double*)(_retArea.ptr + 80) = cast(double)(_payload6264.delta[2]); + *cast(float*)(_retArea.ptr + 88) = cast(float)(_payload6264.yaw); + *cast(float*)(_retArea.ptr + 92) = cast(float)(_payload6264.pitch); + auto _listSrc6266 = _payload6264.relatives; + auto _list6266 = _listSrc6266.length ? wit.common.malloc(_listSrc6266.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc6266.length || _list6266); + foreach (_elem6265_idx, ref _elem6265; _listSrc6266) { + auto _base6265 = _list6266 + _elem6265_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6265 + size_t.sizeof) = cast(size_t)(_elem6265.length); + *cast(void**)(_base6265 + 0) = cast(void*)(cast(void*)(_elem6265.ptr)); + + } + if (_listSrc6266.length) wit.common.free(_listSrc6266.ptr); + *cast(size_t*)(_retArea.ptr + (96+1*size_t.sizeof)) = cast(size_t)(_payload6264.relatives.length); + *cast(void**)(_retArea.ptr + 96) = cast(void*)(_list6266); + *cast(ubyte*)(_retArea.ptr + (96+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6264.onGround)); + break; + } + case _Tag6350.cTestInstanceBlockStatus: { + ref wit.pumpkin.plugin.java_packets.common.CTestInstanceBlockStatus _payload6268 = _payload5597.getCTestInstanceBlockStatus(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(146); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6268.pos[0])); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6268.pos[1])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload6268.pos[2])); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload6268.status)); + if (_payload6268.message.isSome) { + ref _payload6272 = _payload6268.message.unwrap(); + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(size_t)(_payload6272.length); + *cast(void**)(_retArea.ptr + (48+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6272.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(0); + } + break; + } + case _Tag6350.cTickingState: { + ref wit.pumpkin.plugin.java_packets.common.CTickingState _payload6274 = _payload5597.getCTickingState(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(147); + *cast(float*)(_retArea.ptr + 32) = cast(float)(_payload6274.tickRate); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(cast(uint)(_payload6274.isFrozen)); + break; + } + case _Tag6350.cTickingStep: { + ref wit.pumpkin.plugin.java_packets.common.CTickingStep _payload6276 = _payload5597.getCTickingStep(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(148); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6276.tickSteps)); + break; + } + case _Tag6350.cTransfer: { + ref wit.pumpkin.plugin.java_packets.common.CTransfer _payload6278 = _payload5597.getCTransfer(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(149); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6278.host.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6278.host.ptr)); + *cast(uint*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6278.port)); + break; + } + case _Tag6350.cUnloadChunk: { + ref wit.pumpkin.plugin.java_packets.common.CUnloadChunk _payload6280 = _payload5597.getCUnloadChunk(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(150); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6280.x)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6280.z)); + break; + } + case _Tag6350.cUpdateAdvancements: { + ref wit.pumpkin.plugin.java_packets.common.CUpdateAdvancements _payload6282 = _payload5597.getCUpdateAdvancements(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(151); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6282.reset)); + auto _listSrc6284 = _payload6282.added; + auto _list6284 = _listSrc6284.length ? wit.common.malloc(_listSrc6284.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc6284.length || _list6284); + foreach (_elem6283_idx, ref _elem6283; _listSrc6284) { + auto _base6283 = _list6284 + _elem6283_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6283 + size_t.sizeof) = cast(size_t)(_elem6283.length); + *cast(void**)(_base6283 + 0) = cast(void*)(cast(void*)(_elem6283.ptr)); + + } + if (_listSrc6284.length) wit.common.free(_listSrc6284.ptr); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload6282.added.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(_list6284); + auto _listSrc6286 = _payload6282.removed; + auto _list6286 = _listSrc6286.length ? wit.common.malloc(_listSrc6286.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc6286.length || _list6286); + foreach (_elem6285_idx, ref _elem6285; _listSrc6286) { + auto _base6285 = _list6286 + _elem6285_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6285 + size_t.sizeof) = cast(size_t)(_elem6285.length); + *cast(void**)(_base6285 + 0) = cast(void*)(cast(void*)(_elem6285.ptr)); + + } + if (_listSrc6286.length) wit.common.free(_listSrc6286.ptr); + *cast(size_t*)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(size_t)(_payload6282.removed.length); + *cast(void**)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(void*)(_list6286); + auto _listSrc6288 = _payload6282.progress; + auto _list6288 = _listSrc6288.length ? wit.common.malloc(_listSrc6288.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc6288.length || _list6288); + foreach (_elem6287_idx, ref _elem6287; _listSrc6288) { + auto _base6287 = _list6288 + _elem6287_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6287 + size_t.sizeof) = cast(size_t)(_elem6287.length); + *cast(void**)(_base6287 + 0) = cast(void*)(cast(void*)(_elem6287.ptr)); + + } + if (_listSrc6288.length) wit.common.free(_listSrc6288.ptr); + *cast(size_t*)(_retArea.ptr + (32+6*size_t.sizeof)) = cast(size_t)(_payload6282.progress.length); + *cast(void**)(_retArea.ptr + (32+5*size_t.sizeof)) = cast(void*)(_list6288); + *cast(ubyte*)(_retArea.ptr + (32+7*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6282.showAdvancements)); + break; + } + case _Tag6350.cUpdateAttributes: { + ref wit.pumpkin.plugin.java_packets.common.CUpdateAttributes _payload6290 = _payload5597.getCUpdateAttributes(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(152); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6290.entityId)); + auto _listSrc6294 = _payload6290.properties; + auto _list6294 = _listSrc6294.length ? wit.common.malloc(_listSrc6294.length * ((16+2*size_t.sizeof))) : null; + assert(!_listSrc6294.length || _list6294); + foreach (_elem6291_idx, ref _elem6291; _listSrc6294) { + auto _base6291 = _list6294 + _elem6291_idx * ((16+2*size_t.sizeof)); + *cast(uint*)(_base6291 + 0) = cast(uint)(cast(uint)(_elem6291.id)); + *cast(double*)(_base6291 + 8) = cast(double)(_elem6291.value); + auto _listSrc6293 = _elem6291.modifiers; + auto _list6293 = _listSrc6293.length ? wit.common.malloc(_listSrc6293.length * ((16+2*size_t.sizeof))) : null; + assert(!_listSrc6293.length || _list6293); + foreach (_elem6292_idx, ref _elem6292; _listSrc6293) { + auto _base6292 = _list6293 + _elem6292_idx * ((16+2*size_t.sizeof)); + *cast(size_t*)(_base6292 + size_t.sizeof) = cast(size_t)(_elem6292.id.length); + *cast(void**)(_base6292 + 0) = cast(void*)(cast(void*)(_elem6292.id.ptr)); + *cast(double*)(_base6292 + (2*size_t.sizeof)) = cast(double)(_elem6292.amount); + *cast(ubyte*)(_base6292 + (8+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6292.operation)); + + } + if (_listSrc6293.length) wit.common.free(_listSrc6293.ptr); + *cast(size_t*)(_base6291 + (16+1*size_t.sizeof)) = cast(size_t)(_elem6291.modifiers.length); + *cast(void**)(_base6291 + 16) = cast(void*)(_list6293); + + } + if (_listSrc6294.length) wit.common.free(_listSrc6294.ptr); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload6290.properties.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(_list6294); + break; + } + case _Tag6350.cUpdateEntityPos: { + ref wit.pumpkin.plugin.java_packets.common.CUpdateEntityPos _payload6296 = _payload5597.getCUpdateEntityPos(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(153); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6296.entityId)); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload6296.delta[0]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload6296.delta[1]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload6296.delta[2]); + *cast(ubyte*)(_retArea.ptr + 64) = cast(ubyte)(cast(uint)(_payload6296.onGround)); + break; + } + case _Tag6350.cUpdateEntityPosRot: { + ref wit.pumpkin.plugin.java_packets.common.CUpdateEntityPosRot _payload6298 = _payload5597.getCUpdateEntityPosRot(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(154); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6298.entityId)); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload6298.delta[0]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload6298.delta[1]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload6298.delta[2]); + *cast(ubyte*)(_retArea.ptr + 64) = cast(ubyte)(cast(uint)(_payload6298.yaw)); + *cast(ubyte*)(_retArea.ptr + 65) = cast(ubyte)(cast(uint)(_payload6298.pitch)); + *cast(ubyte*)(_retArea.ptr + 66) = cast(ubyte)(cast(uint)(_payload6298.onGround)); + break; + } + case _Tag6350.cUpdateEntityRot: { + ref wit.pumpkin.plugin.java_packets.common.CUpdateEntityRot _payload6300 = _payload5597.getCUpdateEntityRot(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(155); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6300.entityId)); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(cast(uint)(_payload6300.yaw)); + *cast(ubyte*)(_retArea.ptr + 37) = cast(ubyte)(cast(uint)(_payload6300.pitch)); + *cast(ubyte*)(_retArea.ptr + 38) = cast(ubyte)(cast(uint)(_payload6300.onGround)); + break; + } + case _Tag6350.cUpdateMobEffect: { + ref wit.pumpkin.plugin.java_packets.common.CUpdateMobEffect _payload6302 = _payload5597.getCUpdateMobEffect(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(156); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6302.entityId)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6302.effectId)); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload6302.amplifier)); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload6302.duration)); + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(cast(uint)(_payload6302.flags)); + break; + } + case _Tag6350.cUpdateObjectives: { + ref wit.pumpkin.plugin.java_packets.common.CUpdateObjectives _payload6304 = _payload5597.getCUpdateObjectives(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(157); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6304.objectiveName.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6304.objectiveName.ptr)); + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6304.mode)); + *cast(size_t*)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(size_t)(_payload6304.displayName.length); + *cast(void**)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6304.displayName.ptr)); + *cast(uint*)(_retArea.ptr + (32+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6304.renderType)); + if (_payload6304.numberFormat.isSome) { + ref _payload6308 = _payload6304.numberFormat.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+6*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+8*size_t.sizeof)) = cast(size_t)(_payload6308.length); + *cast(void**)(_retArea.ptr + (32+7*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6308.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (32+6*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag6350.cUpdateRecipes: { + ref wit.pumpkin.plugin.java_packets.common.CUpdateRecipes _payload6310 = _payload5597.getCUpdateRecipes(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(158); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6310.rawData.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6310.rawData.ptr)); + break; + } + case _Tag6350.cUpdateScore: { + ref wit.pumpkin.plugin.java_packets.common.CUpdateScore _payload6312 = _payload5597.getCUpdateScore(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(159); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6312.entityName.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6312.entityName.ptr)); + *cast(size_t*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(size_t)(_payload6312.objectiveName.length); + *cast(void**)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6312.objectiveName.ptr)); + *cast(uint*)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6312.value)); + if (_payload6312.displayName.isSome) { + ref _payload6316 = _payload6312.displayName.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+5*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+7*size_t.sizeof)) = cast(size_t)(_payload6316.length); + *cast(void**)(_retArea.ptr + (32+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6316.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (32+5*size_t.sizeof)) = cast(ubyte)(0); + } + if (_payload6312.numberFormat.isSome) { + ref _payload6320 = _payload6312.numberFormat.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+8*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+10*size_t.sizeof)) = cast(size_t)(_payload6320.length); + *cast(void**)(_retArea.ptr + (32+9*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6320.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (32+8*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag6350.cUseBed: { + ref wit.pumpkin.plugin.java_packets.common.CUseBed _payload6322 = _payload5597.getCUseBed(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(160); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6322.entityId)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6322.location[0])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload6322.location[1])); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload6322.location[2])); + break; + } + case _Tag6350.cWaypoint: { + ref wit.pumpkin.plugin.java_packets.common.CWaypoint _payload6324 = _payload5597.getCWaypoint(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(161); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6324.operation)); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(_payload6324.waypoint.identifier.high); + *cast(ulong*)(_retArea.ptr + 48) = cast(ulong)(_payload6324.waypoint.identifier.low); + if (_payload6324.waypoint.icon.isSome) { + ref _payload6328 = _payload6324.waypoint.icon.unwrap(); + *cast(ubyte*)(_retArea.ptr + 56) = cast(ubyte)(1); + if (_payload6328.style.isSome) { + ref _payload6332 = _payload6328.style.unwrap(); + *cast(ubyte*)(_retArea.ptr + (56+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (56+3*size_t.sizeof)) = cast(size_t)(_payload6332.length); + *cast(void**)(_retArea.ptr + (56+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6332.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (56+1*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(uint*)(_retArea.ptr + (56+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6328.color)); + } else { + *cast(ubyte*)(_retArea.ptr + 56) = cast(ubyte)(0); + } + alias _Tag6341 = wit.pumpkin.plugin.java_packets.common.WaypointTarget.Tag; + final switch (_payload6324.waypoint.target.tag) { + case _Tag6341.position: { + ref Tuple!(int, int, int) _payload6334 = _payload6324.waypoint.target.getPosition(); + *cast(ubyte*)(_retArea.ptr + (56+5*size_t.sizeof)) = cast(ubyte)(0); + *cast(uint*)(_retArea.ptr + (60+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6334[0])); + *cast(uint*)(_retArea.ptr + (64+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6334[1])); + *cast(uint*)(_retArea.ptr + (68+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6334[2])); + break; + } + case _Tag6341.chunk: { + ref wit.pumpkin.plugin.java_packets.common.WaypointTargetChunk _payload6336 = _payload6324.waypoint.target.getChunk(); + *cast(ubyte*)(_retArea.ptr + (56+5*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (60+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6336.x)); + *cast(uint*)(_retArea.ptr + (64+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6336.z)); + break; + } + case _Tag6341.azimuth: { + ref float _payload6338 = _payload6324.waypoint.target.getAzimuth(); + *cast(ubyte*)(_retArea.ptr + (56+5*size_t.sizeof)) = cast(ubyte)(2); + *cast(float*)(_retArea.ptr + (60+5*size_t.sizeof)) = cast(float)(_payload6338); + break; + } + case _Tag6341.empty: { + *cast(ubyte*)(_retArea.ptr + (56+5*size_t.sizeof)) = cast(ubyte)(3); + break; + } + } + break; + } + case _Tag6350.cWorldEvent: { + ref wit.pumpkin.plugin.java_packets.common.CWorldEvent _payload6343 = _payload5597.getCWorldEvent(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(162); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6343.event)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6343.location[0])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload6343.location[1])); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload6343.location[2])); + *cast(uint*)(_retArea.ptr + 48) = cast(uint)(cast(uint)(_payload6343.data)); + *cast(ubyte*)(_retArea.ptr + 52) = cast(ubyte)(cast(uint)(_payload6343.disableRelativeVolume)); + break; + } + case _Tag6350.statusCPingResponse: { + ref wit.pumpkin.plugin.java_packets.common.StatusCPingResponse _payload6345 = _payload5597.getStatusCPingResponse(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(163); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload6345.payload)); + break; + } + case _Tag6350.statusCStatusResponse: { + ref wit.pumpkin.plugin.java_packets.common.StatusCStatusResponse _payload6347 = _payload5597.getStatusCStatusResponse(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(164); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6347.jsonResponse.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6347.jsonResponse.ptr)); + break; + } + case _Tag6350.unknown: { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(165); + break; + } + } + break; + } + case _Tag6657.bedrock: { + ref wit.pumpkin.plugin.event.common.BedrockClientboundPacket _payload6352 = _payload5595.packet.getBedrock(); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(1); + alias _Tag6654 = wit.pumpkin.plugin.bedrock_packets.common.ClientboundPacket.Tag; + final switch (_payload6352.tag) { + case _Tag6654.cAddActor: { + ref wit.pumpkin.plugin.bedrock_packets.common.CAddActor _payload6354 = _payload6352.getCAddActor(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(0); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload6354.targetActorId)); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(cast(ulong)(_payload6354.targetRuntimeId)); + *cast(size_t*)(_retArea.ptr + (48+1*size_t.sizeof)) = cast(size_t)(_payload6354.actorType.length); + *cast(void**)(_retArea.ptr + 48) = cast(void*)(cast(void*)(_payload6354.actorType.ptr)); + *cast(double*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(double)(_payload6354.position[0]); + *cast(double*)(_retArea.ptr + (56+2*size_t.sizeof)) = cast(double)(_payload6354.position[1]); + *cast(double*)(_retArea.ptr + (64+2*size_t.sizeof)) = cast(double)(_payload6354.position[2]); + *cast(double*)(_retArea.ptr + (72+2*size_t.sizeof)) = cast(double)(_payload6354.velocity[0]); + *cast(double*)(_retArea.ptr + (80+2*size_t.sizeof)) = cast(double)(_payload6354.velocity[1]); + *cast(double*)(_retArea.ptr + (88+2*size_t.sizeof)) = cast(double)(_payload6354.velocity[2]); + *cast(double*)(_retArea.ptr + (96+2*size_t.sizeof)) = cast(double)(_payload6354.rotation[0]); + *cast(double*)(_retArea.ptr + (104+2*size_t.sizeof)) = cast(double)(_payload6354.rotation[1]); + *cast(float*)(_retArea.ptr + (112+2*size_t.sizeof)) = cast(float)(_payload6354.yHeadRotation); + *cast(float*)(_retArea.ptr + (116+2*size_t.sizeof)) = cast(float)(_payload6354.yBodyRotation); + auto _listSrc6356 = _payload6354.attributesList; + auto _list6356 = _listSrc6356.length ? wit.common.malloc(_listSrc6356.length * ((8+3*size_t.sizeof))) : null; + assert(!_listSrc6356.length || _list6356); + foreach (_elem6355_idx, ref _elem6355; _listSrc6356) { + auto _base6355 = _list6356 + _elem6355_idx * ((8+3*size_t.sizeof)); + *cast(size_t*)(_base6355 + size_t.sizeof) = cast(size_t)(_elem6355.attributeName.length); + *cast(void**)(_base6355 + 0) = cast(void*)(cast(void*)(_elem6355.attributeName.ptr)); + *cast(float*)(_base6355 + (2*size_t.sizeof)) = cast(float)(_elem6355.minValue); + *cast(float*)(_base6355 + (4+2*size_t.sizeof)) = cast(float)(_elem6355.currentValue); + *cast(float*)(_base6355 + (8+2*size_t.sizeof)) = cast(float)(_elem6355.maxValue); + + } + if (_listSrc6356.length) wit.common.free(_listSrc6356.ptr); + *cast(size_t*)(_retArea.ptr + (120+3*size_t.sizeof)) = cast(size_t)(_payload6354.attributesList.length); + *cast(void**)(_retArea.ptr + (120+2*size_t.sizeof)) = cast(void*)(_list6356); + *cast(size_t*)(_retArea.ptr + (120+5*size_t.sizeof)) = cast(size_t)(_payload6354.actorData.length); + *cast(void**)(_retArea.ptr + (120+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6354.actorData.ptr)); + *cast(size_t*)(_retArea.ptr + (120+7*size_t.sizeof)) = cast(size_t)(_payload6354.syncedProperties.intEntriesList.length); + *cast(void**)(_retArea.ptr + (120+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6354.syncedProperties.intEntriesList.ptr)); + *cast(size_t*)(_retArea.ptr + (120+9*size_t.sizeof)) = cast(size_t)(_payload6354.syncedProperties.floatEntriesList.length); + *cast(void**)(_retArea.ptr + (120+8*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6354.syncedProperties.floatEntriesList.ptr)); + auto _listSrc6358 = _payload6354.actorLinks; + auto _list6358 = _listSrc6358.length ? wit.common.malloc(_listSrc6358.length * (24)) : null; + assert(!_listSrc6358.length || _list6358); + foreach (_elem6357_idx, ref _elem6357; _listSrc6358) { + auto _base6357 = _list6358 + _elem6357_idx * (24); + *cast(ulong*)(_base6357 + 0) = cast(ulong)(cast(ulong)(_elem6357.riddenUniqueId)); + *cast(ulong*)(_base6357 + 8) = cast(ulong)(cast(ulong)(_elem6357.riderUniqueId)); + *cast(ubyte*)(_base6357 + 16) = cast(ubyte)(cast(uint)(_elem6357.linkType)); + *cast(ubyte*)(_base6357 + 17) = cast(ubyte)(cast(uint)(_elem6357.immediate)); + *cast(ubyte*)(_base6357 + 18) = cast(ubyte)(cast(uint)(_elem6357.riderInitiated)); + *cast(float*)(_base6357 + 20) = cast(float)(_elem6357.vehicleAngularVelocity); + + } + if (_listSrc6358.length) wit.common.free(_listSrc6358.ptr); + *cast(size_t*)(_retArea.ptr + (120+11*size_t.sizeof)) = cast(size_t)(_payload6354.actorLinks.length); + *cast(void**)(_retArea.ptr + (120+10*size_t.sizeof)) = cast(void*)(_list6358); + break; + } + case _Tag6654.cAddItemActor: { + ref wit.pumpkin.plugin.bedrock_packets.common.CAddItemActor _payload6360 = _payload6352.getCAddItemActor(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(1); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload6360.targetActorId)); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(cast(ulong)(_payload6360.targetRuntimeId)); + *cast(uint*)(_retArea.ptr + 48) = cast(uint)(cast(uint)(_payload6360.item.id)); + *cast(uint*)(_retArea.ptr + 52) = cast(uint)(cast(uint)(_payload6360.item.stackSize)); + *cast(uint*)(_retArea.ptr + 56) = cast(uint)(cast(uint)(_payload6360.item.auxValue)); + *cast(uint*)(_retArea.ptr + 60) = cast(uint)(cast(uint)(_payload6360.item.blockRuntimeId)); + *cast(size_t*)(_retArea.ptr + (64+1*size_t.sizeof)) = cast(size_t)(_payload6360.item.nbtData.length); + *cast(void**)(_retArea.ptr + 64) = cast(void*)(cast(void*)(_payload6360.item.nbtData.ptr)); + auto _listSrc6362 = _payload6360.item.placeOnBlocks; + auto _list6362 = _listSrc6362.length ? wit.common.malloc(_listSrc6362.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc6362.length || _list6362); + foreach (_elem6361_idx, ref _elem6361; _listSrc6362) { + auto _base6361 = _list6362 + _elem6361_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6361 + size_t.sizeof) = cast(size_t)(_elem6361.length); + *cast(void**)(_base6361 + 0) = cast(void*)(cast(void*)(_elem6361.ptr)); + + } + if (_listSrc6362.length) wit.common.free(_listSrc6362.ptr); + *cast(size_t*)(_retArea.ptr + (64+3*size_t.sizeof)) = cast(size_t)(_payload6360.item.placeOnBlocks.length); + *cast(void**)(_retArea.ptr + (64+2*size_t.sizeof)) = cast(void*)(_list6362); + auto _listSrc6364 = _payload6360.item.destroyBlocks; + auto _list6364 = _listSrc6364.length ? wit.common.malloc(_listSrc6364.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc6364.length || _list6364); + foreach (_elem6363_idx, ref _elem6363; _listSrc6364) { + auto _base6363 = _list6364 + _elem6363_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6363 + size_t.sizeof) = cast(size_t)(_elem6363.length); + *cast(void**)(_base6363 + 0) = cast(void*)(cast(void*)(_elem6363.ptr)); + + } + if (_listSrc6364.length) wit.common.free(_listSrc6364.ptr); + *cast(size_t*)(_retArea.ptr + (64+5*size_t.sizeof)) = cast(size_t)(_payload6360.item.destroyBlocks.length); + *cast(void**)(_retArea.ptr + (64+4*size_t.sizeof)) = cast(void*)(_list6364); + *cast(ulong*)(_retArea.ptr + (64+6*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload6360.item.shieldBlockingTick)); + if (_payload6360.item.netId.isSome) { + ref _payload6368 = _payload6360.item.netId.unwrap(); + *cast(ubyte*)(_retArea.ptr + (72+6*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (76+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6368)); + } else { + *cast(ubyte*)(_retArea.ptr + (72+6*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(double*)(_retArea.ptr + (80+6*size_t.sizeof)) = cast(double)(_payload6360.position[0]); + *cast(double*)(_retArea.ptr + (88+6*size_t.sizeof)) = cast(double)(_payload6360.position[1]); + *cast(double*)(_retArea.ptr + (96+6*size_t.sizeof)) = cast(double)(_payload6360.position[2]); + *cast(double*)(_retArea.ptr + (104+6*size_t.sizeof)) = cast(double)(_payload6360.velocity[0]); + *cast(double*)(_retArea.ptr + (112+6*size_t.sizeof)) = cast(double)(_payload6360.velocity[1]); + *cast(double*)(_retArea.ptr + (120+6*size_t.sizeof)) = cast(double)(_payload6360.velocity[2]); + *cast(size_t*)(_retArea.ptr + (128+7*size_t.sizeof)) = cast(size_t)(_payload6360.entityData.length); + *cast(void**)(_retArea.ptr + (128+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6360.entityData.ptr)); + *cast(ubyte*)(_retArea.ptr + (128+8*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6360.isFromFishing)); + break; + } + case _Tag6654.cAddPlayer: { + ref wit.pumpkin.plugin.bedrock_packets.common.CAddPlayer _payload6370 = _payload6352.getCAddPlayer(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(2); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(_payload6370.uuid.high); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(_payload6370.uuid.low); + *cast(size_t*)(_retArea.ptr + (48+1*size_t.sizeof)) = cast(size_t)(_payload6370.playerName.length); + *cast(void**)(_retArea.ptr + 48) = cast(void*)(cast(void*)(_payload6370.playerName.ptr)); + *cast(ulong*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload6370.targetRuntimeId)); + *cast(size_t*)(_retArea.ptr + (56+3*size_t.sizeof)) = cast(size_t)(_payload6370.platformChatId.length); + *cast(void**)(_retArea.ptr + (56+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6370.platformChatId.ptr)); + *cast(double*)(_retArea.ptr + (56+4*size_t.sizeof)) = cast(double)(_payload6370.position[0]); + *cast(double*)(_retArea.ptr + (64+4*size_t.sizeof)) = cast(double)(_payload6370.position[1]); + *cast(double*)(_retArea.ptr + (72+4*size_t.sizeof)) = cast(double)(_payload6370.position[2]); + *cast(double*)(_retArea.ptr + (80+4*size_t.sizeof)) = cast(double)(_payload6370.velocity[0]); + *cast(double*)(_retArea.ptr + (88+4*size_t.sizeof)) = cast(double)(_payload6370.velocity[1]); + *cast(double*)(_retArea.ptr + (96+4*size_t.sizeof)) = cast(double)(_payload6370.velocity[2]); + *cast(double*)(_retArea.ptr + (104+4*size_t.sizeof)) = cast(double)(_payload6370.rotation[0]); + *cast(double*)(_retArea.ptr + (112+4*size_t.sizeof)) = cast(double)(_payload6370.rotation[1]); + *cast(float*)(_retArea.ptr + (120+4*size_t.sizeof)) = cast(float)(_payload6370.yHeadRotation); + *cast(uint*)(_retArea.ptr + (120+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6370.carriedItem.id)); + *cast(uint*)(_retArea.ptr + (124+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6370.carriedItem.stackSize)); + *cast(uint*)(_retArea.ptr + (128+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6370.carriedItem.auxValue)); + *cast(uint*)(_retArea.ptr + (132+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6370.carriedItem.blockRuntimeId)); + *cast(size_t*)(_retArea.ptr + (136+6*size_t.sizeof)) = cast(size_t)(_payload6370.carriedItem.extraData.length); + *cast(void**)(_retArea.ptr + (136+5*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6370.carriedItem.extraData.ptr)); + if (_payload6370.carriedItem.netId.isSome) { + ref _payload6374 = _payload6370.carriedItem.netId.unwrap(); + *cast(ubyte*)(_retArea.ptr + (136+7*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (140+7*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6374)); + } else { + *cast(ubyte*)(_retArea.ptr + (136+7*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + (144+7*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6370.playerGameType)); + *cast(size_t*)(_retArea.ptr + (144+9*size_t.sizeof)) = cast(size_t)(_payload6370.entityData.length); + *cast(void**)(_retArea.ptr + (144+8*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6370.entityData.ptr)); + *cast(size_t*)(_retArea.ptr + (144+11*size_t.sizeof)) = cast(size_t)(_payload6370.syncedProperties.intEntriesList.length); + *cast(void**)(_retArea.ptr + (144+10*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6370.syncedProperties.intEntriesList.ptr)); + *cast(size_t*)(_retArea.ptr + (144+13*size_t.sizeof)) = cast(size_t)(_payload6370.syncedProperties.floatEntriesList.length); + *cast(void**)(_retArea.ptr + (144+12*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6370.syncedProperties.floatEntriesList.ptr)); + *cast(ulong*)(_retArea.ptr + (144+14*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload6370.abilitiesData.targetPlayerRawId)); + *cast(ubyte*)(_retArea.ptr + (152+14*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6370.abilitiesData.playerPermissions)); + *cast(ubyte*)(_retArea.ptr + (153+14*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6370.abilitiesData.commandPermissions)); + *cast(size_t*)(_retArea.ptr + (152+16*size_t.sizeof)) = cast(size_t)(_payload6370.abilitiesData.layers.length); + *cast(void**)(_retArea.ptr + (152+15*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6370.abilitiesData.layers.ptr)); + auto _listSrc6376 = _payload6370.actorLinks; + auto _list6376 = _listSrc6376.length ? wit.common.malloc(_listSrc6376.length * (24)) : null; + assert(!_listSrc6376.length || _list6376); + foreach (_elem6375_idx, ref _elem6375; _listSrc6376) { + auto _base6375 = _list6376 + _elem6375_idx * (24); + *cast(ulong*)(_base6375 + 0) = cast(ulong)(cast(ulong)(_elem6375.riddenUniqueId)); + *cast(ulong*)(_base6375 + 8) = cast(ulong)(cast(ulong)(_elem6375.riderUniqueId)); + *cast(ubyte*)(_base6375 + 16) = cast(ubyte)(cast(uint)(_elem6375.linkType)); + *cast(ubyte*)(_base6375 + 17) = cast(ubyte)(cast(uint)(_elem6375.immediate)); + *cast(ubyte*)(_base6375 + 18) = cast(ubyte)(cast(uint)(_elem6375.riderInitiated)); + *cast(float*)(_base6375 + 20) = cast(float)(_elem6375.vehicleAngularVelocity); + + } + if (_listSrc6376.length) wit.common.free(_listSrc6376.ptr); + *cast(size_t*)(_retArea.ptr + (160+17*size_t.sizeof)) = cast(size_t)(_payload6370.actorLinks.length); + *cast(void**)(_retArea.ptr + (160+16*size_t.sizeof)) = cast(void*)(_list6376); + *cast(size_t*)(_retArea.ptr + (160+19*size_t.sizeof)) = cast(size_t)(_payload6370.deviceId.length); + *cast(void**)(_retArea.ptr + (160+18*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6370.deviceId.ptr)); + *cast(ubyte*)(_retArea.ptr + (160+20*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6370.buildPlatform)); + break; + } + case _Tag6654.cAvailableCommands: { + ref wit.pumpkin.plugin.bedrock_packets.common.CAvailableCommands _payload6378 = _payload6352.getCAvailableCommands(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(3); + auto _listSrc6380 = _payload6378.enumValues; + auto _list6380 = _listSrc6380.length ? wit.common.malloc(_listSrc6380.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc6380.length || _list6380); + foreach (_elem6379_idx, ref _elem6379; _listSrc6380) { + auto _base6379 = _list6380 + _elem6379_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6379 + size_t.sizeof) = cast(size_t)(_elem6379.length); + *cast(void**)(_base6379 + 0) = cast(void*)(cast(void*)(_elem6379.ptr)); + + } + if (_listSrc6380.length) wit.common.free(_listSrc6380.ptr); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6378.enumValues.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(_list6380); + auto _listSrc6382 = _payload6378.chainedSubcommandValues; + auto _list6382 = _listSrc6382.length ? wit.common.malloc(_listSrc6382.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc6382.length || _list6382); + foreach (_elem6381_idx, ref _elem6381; _listSrc6382) { + auto _base6381 = _list6382 + _elem6381_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6381 + size_t.sizeof) = cast(size_t)(_elem6381.length); + *cast(void**)(_base6381 + 0) = cast(void*)(cast(void*)(_elem6381.ptr)); + + } + if (_listSrc6382.length) wit.common.free(_listSrc6382.ptr); + *cast(size_t*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(size_t)(_payload6378.chainedSubcommandValues.length); + *cast(void**)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(void*)(_list6382); + auto _listSrc6384 = _payload6378.postFixes; + auto _list6384 = _listSrc6384.length ? wit.common.malloc(_listSrc6384.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc6384.length || _list6384); + foreach (_elem6383_idx, ref _elem6383; _listSrc6384) { + auto _base6383 = _list6384 + _elem6383_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6383 + size_t.sizeof) = cast(size_t)(_elem6383.length); + *cast(void**)(_base6383 + 0) = cast(void*)(cast(void*)(_elem6383.ptr)); + + } + if (_listSrc6384.length) wit.common.free(_listSrc6384.ptr); + *cast(size_t*)(_retArea.ptr + (32+5*size_t.sizeof)) = cast(size_t)(_payload6378.postFixes.length); + *cast(void**)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(void*)(_list6384); + auto _listSrc6386 = _payload6378.enumData; + auto _list6386 = _listSrc6386.length ? wit.common.malloc(_listSrc6386.length * ((4*size_t.sizeof))) : null; + assert(!_listSrc6386.length || _list6386); + foreach (_elem6385_idx, ref _elem6385; _listSrc6386) { + auto _base6385 = _list6386 + _elem6385_idx * ((4*size_t.sizeof)); + *cast(size_t*)(_base6385 + size_t.sizeof) = cast(size_t)(_elem6385.name.length); + *cast(void**)(_base6385 + 0) = cast(void*)(cast(void*)(_elem6385.name.ptr)); + *cast(size_t*)(_base6385 + (3*size_t.sizeof)) = cast(size_t)(_elem6385.values.length); + *cast(void**)(_base6385 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6385.values.ptr)); + + } + if (_listSrc6386.length) wit.common.free(_listSrc6386.ptr); + *cast(size_t*)(_retArea.ptr + (32+7*size_t.sizeof)) = cast(size_t)(_payload6378.enumData.length); + *cast(void**)(_retArea.ptr + (32+6*size_t.sizeof)) = cast(void*)(_list6386); + auto _listSrc6388 = _payload6378.chainedSubcommandData; + auto _list6388 = _listSrc6388.length ? wit.common.malloc(_listSrc6388.length * ((4*size_t.sizeof))) : null; + assert(!_listSrc6388.length || _list6388); + foreach (_elem6387_idx, ref _elem6387; _listSrc6388) { + auto _base6387 = _list6388 + _elem6387_idx * ((4*size_t.sizeof)); + *cast(size_t*)(_base6387 + size_t.sizeof) = cast(size_t)(_elem6387.name.length); + *cast(void**)(_base6387 + 0) = cast(void*)(cast(void*)(_elem6387.name.ptr)); + *cast(size_t*)(_base6387 + (3*size_t.sizeof)) = cast(size_t)(_elem6387.subcommandValues.length); + *cast(void**)(_base6387 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6387.subcommandValues.ptr)); + + } + if (_listSrc6388.length) wit.common.free(_listSrc6388.ptr); + *cast(size_t*)(_retArea.ptr + (32+9*size_t.sizeof)) = cast(size_t)(_payload6378.chainedSubcommandData.length); + *cast(void**)(_retArea.ptr + (32+8*size_t.sizeof)) = cast(void*)(_list6388); + auto _listSrc6394 = _payload6378.commands; + auto _list6394 = _listSrc6394.length ? wit.common.malloc(_listSrc6394.length * ((8+9*size_t.sizeof))) : null; + assert(!_listSrc6394.length || _list6394); + foreach (_elem6389_idx, ref _elem6389; _listSrc6394) { + auto _base6389 = _list6394 + _elem6389_idx * ((8+9*size_t.sizeof)); + *cast(size_t*)(_base6389 + size_t.sizeof) = cast(size_t)(_elem6389.name.length); + *cast(void**)(_base6389 + 0) = cast(void*)(cast(void*)(_elem6389.name.ptr)); + *cast(size_t*)(_base6389 + (3*size_t.sizeof)) = cast(size_t)(_elem6389.description.length); + *cast(void**)(_base6389 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6389.description.ptr)); + *cast(uint*)(_base6389 + (4*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6389.flags)); + *cast(ubyte*)(_base6389 + (4+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6389.permissionLevel)); + *cast(uint*)(_base6389 + (8+4*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6389.aliasEnum)); + *cast(size_t*)(_base6389 + (8+6*size_t.sizeof)) = cast(size_t)(_elem6389.commandDataChainedSubcommandIndexes.length); + *cast(void**)(_base6389 + (8+5*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6389.commandDataChainedSubcommandIndexes.ptr)); + auto _listSrc6393 = _elem6389.overloads; + auto _list6393 = _listSrc6393.length ? wit.common.malloc(_listSrc6393.length * ((3*size_t.sizeof))) : null; + assert(!_listSrc6393.length || _list6393); + foreach (_elem6390_idx, ref _elem6390; _listSrc6393) { + auto _base6390 = _list6393 + _elem6390_idx * ((3*size_t.sizeof)); + *cast(ubyte*)(_base6390 + 0) = cast(ubyte)(cast(uint)(_elem6390.isChaining)); + auto _listSrc6392 = _elem6390.parameterData; + auto _list6392 = _listSrc6392.length ? wit.common.malloc(_listSrc6392.length * ((8+2*size_t.sizeof))) : null; + assert(!_listSrc6392.length || _list6392); + foreach (_elem6391_idx, ref _elem6391; _listSrc6392) { + auto _base6391 = _list6392 + _elem6391_idx * ((8+2*size_t.sizeof)); + *cast(size_t*)(_base6391 + size_t.sizeof) = cast(size_t)(_elem6391.name.length); + *cast(void**)(_base6391 + 0) = cast(void*)(cast(void*)(_elem6391.name.ptr)); + *cast(uint*)(_base6391 + (2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6391.parseSymbol)); + *cast(ubyte*)(_base6391 + (4+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6391.isOptional)); + *cast(ubyte*)(_base6391 + (5+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6391.options)); + + } + if (_listSrc6392.length) wit.common.free(_listSrc6392.ptr); + *cast(size_t*)(_base6390 + (2*size_t.sizeof)) = cast(size_t)(_elem6390.parameterData.length); + *cast(void**)(_base6390 + size_t.sizeof) = cast(void*)(_list6392); + + } + if (_listSrc6393.length) wit.common.free(_listSrc6393.ptr); + *cast(size_t*)(_base6389 + (8+8*size_t.sizeof)) = cast(size_t)(_elem6389.overloads.length); + *cast(void**)(_base6389 + (8+7*size_t.sizeof)) = cast(void*)(_list6393); + + } + if (_listSrc6394.length) wit.common.free(_listSrc6394.ptr); + *cast(size_t*)(_retArea.ptr + (32+11*size_t.sizeof)) = cast(size_t)(_payload6378.commands.length); + *cast(void**)(_retArea.ptr + (32+10*size_t.sizeof)) = cast(void*)(_list6394); + auto _listSrc6398 = _payload6378.softEnums; + auto _list6398 = _listSrc6398.length ? wit.common.malloc(_listSrc6398.length * ((4*size_t.sizeof))) : null; + assert(!_listSrc6398.length || _list6398); + foreach (_elem6395_idx, ref _elem6395; _listSrc6398) { + auto _base6395 = _list6398 + _elem6395_idx * ((4*size_t.sizeof)); + *cast(size_t*)(_base6395 + size_t.sizeof) = cast(size_t)(_elem6395.enumName.length); + *cast(void**)(_base6395 + 0) = cast(void*)(cast(void*)(_elem6395.enumName.ptr)); + auto _listSrc6397 = _elem6395.enumOptions; + auto _list6397 = _listSrc6397.length ? wit.common.malloc(_listSrc6397.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc6397.length || _list6397); + foreach (_elem6396_idx, ref _elem6396; _listSrc6397) { + auto _base6396 = _list6397 + _elem6396_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6396 + size_t.sizeof) = cast(size_t)(_elem6396.length); + *cast(void**)(_base6396 + 0) = cast(void*)(cast(void*)(_elem6396.ptr)); + + } + if (_listSrc6397.length) wit.common.free(_listSrc6397.ptr); + *cast(size_t*)(_base6395 + (3*size_t.sizeof)) = cast(size_t)(_elem6395.enumOptions.length); + *cast(void**)(_base6395 + (2*size_t.sizeof)) = cast(void*)(_list6397); + + } + if (_listSrc6398.length) wit.common.free(_listSrc6398.ptr); + *cast(size_t*)(_retArea.ptr + (32+13*size_t.sizeof)) = cast(size_t)(_payload6378.softEnums.length); + *cast(void**)(_retArea.ptr + (32+12*size_t.sizeof)) = cast(void*)(_list6398); + auto _listSrc6400 = _payload6378.constraints; + auto _list6400 = _listSrc6400.length ? wit.common.malloc(_listSrc6400.length * ((8+2*size_t.sizeof))) : null; + assert(!_listSrc6400.length || _list6400); + foreach (_elem6399_idx, ref _elem6399; _listSrc6400) { + auto _base6399 = _list6400 + _elem6399_idx * ((8+2*size_t.sizeof)); + *cast(uint*)(_base6399 + 0) = cast(uint)(cast(uint)(_elem6399.enumValueSymbol)); + *cast(uint*)(_base6399 + 4) = cast(uint)(cast(uint)(_elem6399.enumSymbol)); + *cast(size_t*)(_base6399 + (8+1*size_t.sizeof)) = cast(size_t)(_elem6399.constraintIndices.length); + *cast(void**)(_base6399 + 8) = cast(void*)(cast(void*)(_elem6399.constraintIndices.ptr)); + + } + if (_listSrc6400.length) wit.common.free(_listSrc6400.ptr); + *cast(size_t*)(_retArea.ptr + (32+15*size_t.sizeof)) = cast(size_t)(_payload6378.constraints.length); + *cast(void**)(_retArea.ptr + (32+14*size_t.sizeof)) = cast(void*)(_list6400); + break; + } + case _Tag6654.cBiomeDefinitionList: { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(4); + break; + } + case _Tag6654.cBlockActorData: { + ref wit.pumpkin.plugin.bedrock_packets.common.CBlockActorData _payload6404 = _payload6352.getCBlockActorData(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(5); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6404.blockPosition[0])); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6404.blockPosition[1])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload6404.blockPosition[2])); + *cast(size_t*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(size_t)(_payload6404.actorDataTags.length); + *cast(void**)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6404.actorDataTags.ptr)); + break; + } + case _Tag6654.cBlockEvent: { + ref wit.pumpkin.plugin.bedrock_packets.common.CBlockEvent _payload6406 = _payload6352.getCBlockEvent(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(6); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6406.blockPosition[0])); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6406.blockPosition[1])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload6406.blockPosition[2])); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload6406.eventType)); + *cast(uint*)(_retArea.ptr + 48) = cast(uint)(cast(uint)(_payload6406.eventValue)); + break; + } + case _Tag6654.cBossEvent: { + ref wit.pumpkin.plugin.bedrock_packets.common.CBossEvent _payload6408 = _payload6352.getCBossEvent(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(7); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload6408.bossEntityId)); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(cast(ulong)(_payload6408.playerEntityId)); + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(cast(uint)(_payload6408.eventType)); + *cast(size_t*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(size_t)(_payload6408.title.length); + *cast(void**)(_retArea.ptr + (48+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6408.title.ptr)); + *cast(size_t*)(_retArea.ptr + (48+4*size_t.sizeof)) = cast(size_t)(_payload6408.filteredTitle.length); + *cast(void**)(_retArea.ptr + (48+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6408.filteredTitle.ptr)); + *cast(float*)(_retArea.ptr + (48+5*size_t.sizeof)) = cast(float)(_payload6408.healthPercentage); + *cast(ubyte*)(_retArea.ptr + (52+5*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6408.color)); + *cast(ubyte*)(_retArea.ptr + (53+5*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6408.overlay)); + break; + } + case _Tag6654.cChangeDimension: { + ref wit.pumpkin.plugin.bedrock_packets.common.CChangeDimension _payload6410 = _payload6352.getCChangeDimension(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(8); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6410.dimensionId)); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload6410.position[0]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload6410.position[1]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload6410.position[2]); + *cast(ubyte*)(_retArea.ptr + 64) = cast(ubyte)(cast(uint)(_payload6410.respawn)); + if (_payload6410.loadingScreenId.isSome) { + ref _payload6414 = _payload6410.loadingScreenId.unwrap(); + *cast(ubyte*)(_retArea.ptr + 68) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 72) = cast(uint)(cast(uint)(_payload6414)); + } else { + *cast(ubyte*)(_retArea.ptr + 68) = cast(ubyte)(0); + } + break; + } + case _Tag6654.cChunkRadiusUpdated: { + ref wit.pumpkin.plugin.bedrock_packets.common.CChunkRadiusUpdated _payload6416 = _payload6352.getCChunkRadiusUpdated(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(9); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6416.chunkRadius)); + break; + } + case _Tag6654.cClientCacheMissResponse: { + ref wit.pumpkin.plugin.bedrock_packets.common.CClientCacheMissResponse _payload6418 = _payload6352.getCClientCacheMissResponse(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(10); + auto _listSrc6420 = _payload6418.missingBlobs; + auto _list6420 = _listSrc6420.length ? wit.common.malloc(_listSrc6420.length * ((8+2*size_t.sizeof))) : null; + assert(!_listSrc6420.length || _list6420); + foreach (_elem6419_idx, ref _elem6419; _listSrc6420) { + auto _base6419 = _list6420 + _elem6419_idx * ((8+2*size_t.sizeof)); + *cast(ulong*)(_base6419 + 0) = cast(ulong)(cast(ulong)(_elem6419.blobId)); + *cast(size_t*)(_base6419 + (8+1*size_t.sizeof)) = cast(size_t)(_elem6419.blobData.length); + *cast(void**)(_base6419 + 8) = cast(void*)(cast(void*)(_elem6419.blobData.ptr)); + + } + if (_listSrc6420.length) wit.common.free(_listSrc6420.ptr); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6418.missingBlobs.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(_list6420); + break; + } + case _Tag6654.cContainerOpen: { + ref wit.pumpkin.plugin.bedrock_packets.common.CContainerOpen _payload6422 = _payload6352.getCContainerOpen(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(11); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6422.containerId)); + *cast(ubyte*)(_retArea.ptr + 33) = cast(ubyte)(cast(uint)(_payload6422.containerType)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6422.position[0])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload6422.position[1])); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload6422.position[2])); + *cast(ulong*)(_retArea.ptr + 48) = cast(ulong)(cast(ulong)(_payload6422.targetEntityId)); + break; + } + case _Tag6654.cCorrectPlayerMovePrediction: { + ref wit.pumpkin.plugin.bedrock_packets.common.CCorrectPlayerMovePrediction _payload6424 = _payload6352.getCCorrectPlayerMovePrediction(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(12); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6424.predictionType)); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload6424.pos[0]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload6424.pos[1]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload6424.pos[2]); + *cast(double*)(_retArea.ptr + 64) = cast(double)(_payload6424.posDelta[0]); + *cast(double*)(_retArea.ptr + 72) = cast(double)(_payload6424.posDelta[1]); + *cast(double*)(_retArea.ptr + 80) = cast(double)(_payload6424.posDelta[2]); + *cast(double*)(_retArea.ptr + 88) = cast(double)(_payload6424.rotation[0]); + *cast(double*)(_retArea.ptr + 96) = cast(double)(_payload6424.rotation[1]); + if (_payload6424.vehicleAngularVelocity.isSome) { + ref _payload6428 = _payload6424.vehicleAngularVelocity.unwrap(); + *cast(ubyte*)(_retArea.ptr + 104) = cast(ubyte)(1); + *cast(float*)(_retArea.ptr + 108) = cast(float)(_payload6428); + } else { + *cast(ubyte*)(_retArea.ptr + 104) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + 112) = cast(ubyte)(cast(uint)(_payload6424.onGround)); + *cast(ulong*)(_retArea.ptr + 120) = cast(ulong)(cast(ulong)(_payload6424.tick)); + break; + } + case _Tag6654.cCraftingData: { + ref wit.pumpkin.plugin.bedrock_packets.common.CCraftingData _payload6430 = _payload6352.getCCraftingData(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(13); + auto _listSrc6453 = _payload6430.recipes; + auto _list6453 = _listSrc6453.length ? wit.common.malloc(_listSrc6453.length * ((48+8*size_t.sizeof))) : null; + assert(!_listSrc6453.length || _list6453); + foreach (_elem6431_idx, ref _elem6431; _listSrc6453) { + auto _base6431 = _list6453 + _elem6431_idx * ((48+8*size_t.sizeof)); + alias _Tag6452 = wit.pumpkin.plugin.bedrock_packets.common.BedrockRecipe.Tag; + final switch (_elem6431.tag) { + case _Tag6452.shapeless: { + ref wit.pumpkin.plugin.bedrock_packets.common.BedrockShapelessRecipe _payload6433 = _elem6431.getShapeless(); + *cast(ubyte*)(_base6431 + 0) = cast(ubyte)(0); + *cast(size_t*)(_base6431 + (8+1*size_t.sizeof)) = cast(size_t)(_payload6433.recipeId.length); + *cast(void**)(_base6431 + 8) = cast(void*)(cast(void*)(_payload6433.recipeId.ptr)); + auto _listSrc6435 = _payload6433.input; + auto _list6435 = _listSrc6435.length ? wit.common.malloc(_listSrc6435.length * ((8+2*size_t.sizeof))) : null; + assert(!_listSrc6435.length || _list6435); + foreach (_elem6434_idx, ref _elem6434; _listSrc6435) { + auto _base6434 = _list6435 + _elem6434_idx * ((8+2*size_t.sizeof)); + *cast(size_t*)(_base6434 + size_t.sizeof) = cast(size_t)(_elem6434.itemIdentifier.length); + *cast(void**)(_base6434 + 0) = cast(void*)(cast(void*)(_elem6434.itemIdentifier.ptr)); + *cast(uint*)(_base6434 + (2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6434.metadataValue)); + *cast(uint*)(_base6434 + (4+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6434.count)); + + } + if (_listSrc6435.length) wit.common.free(_listSrc6435.ptr); + *cast(size_t*)(_base6431 + (8+3*size_t.sizeof)) = cast(size_t)(_payload6433.input.length); + *cast(void**)(_base6431 + (8+2*size_t.sizeof)) = cast(void*)(_list6435); + auto _listSrc6441 = _payload6433.output; + auto _list6441 = _listSrc6441.length ? wit.common.malloc(_listSrc6441.length * ((24+6*size_t.sizeof))) : null; + assert(!_listSrc6441.length || _list6441); + foreach (_elem6436_idx, ref _elem6436; _listSrc6441) { + auto _base6436 = _list6441 + _elem6436_idx * ((24+6*size_t.sizeof)); + *cast(uint*)(_base6436 + 0) = cast(uint)(cast(uint)(_elem6436.id)); + *cast(uint*)(_base6436 + 4) = cast(uint)(cast(uint)(_elem6436.stackSize)); + *cast(uint*)(_base6436 + 8) = cast(uint)(cast(uint)(_elem6436.auxValue)); + *cast(uint*)(_base6436 + 12) = cast(uint)(cast(uint)(_elem6436.blockRuntimeId)); + *cast(size_t*)(_base6436 + (16+1*size_t.sizeof)) = cast(size_t)(_elem6436.nbtData.length); + *cast(void**)(_base6436 + 16) = cast(void*)(cast(void*)(_elem6436.nbtData.ptr)); + auto _listSrc6438 = _elem6436.placeOnBlocks; + auto _list6438 = _listSrc6438.length ? wit.common.malloc(_listSrc6438.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc6438.length || _list6438); + foreach (_elem6437_idx, ref _elem6437; _listSrc6438) { + auto _base6437 = _list6438 + _elem6437_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6437 + size_t.sizeof) = cast(size_t)(_elem6437.length); + *cast(void**)(_base6437 + 0) = cast(void*)(cast(void*)(_elem6437.ptr)); + + } + if (_listSrc6438.length) wit.common.free(_listSrc6438.ptr); + *cast(size_t*)(_base6436 + (16+3*size_t.sizeof)) = cast(size_t)(_elem6436.placeOnBlocks.length); + *cast(void**)(_base6436 + (16+2*size_t.sizeof)) = cast(void*)(_list6438); + auto _listSrc6440 = _elem6436.destroyBlocks; + auto _list6440 = _listSrc6440.length ? wit.common.malloc(_listSrc6440.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc6440.length || _list6440); + foreach (_elem6439_idx, ref _elem6439; _listSrc6440) { + auto _base6439 = _list6440 + _elem6439_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6439 + size_t.sizeof) = cast(size_t)(_elem6439.length); + *cast(void**)(_base6439 + 0) = cast(void*)(cast(void*)(_elem6439.ptr)); + + } + if (_listSrc6440.length) wit.common.free(_listSrc6440.ptr); + *cast(size_t*)(_base6436 + (16+5*size_t.sizeof)) = cast(size_t)(_elem6436.destroyBlocks.length); + *cast(void**)(_base6436 + (16+4*size_t.sizeof)) = cast(void*)(_list6440); + *cast(ulong*)(_base6436 + (16+6*size_t.sizeof)) = cast(ulong)(cast(ulong)(_elem6436.shieldBlockingTick)); + + } + if (_listSrc6441.length) wit.common.free(_listSrc6441.ptr); + *cast(size_t*)(_base6431 + (8+5*size_t.sizeof)) = cast(size_t)(_payload6433.output.length); + *cast(void**)(_base6431 + (8+4*size_t.sizeof)) = cast(void*)(_list6441); + *cast(ulong*)(_base6431 + (8+6*size_t.sizeof)) = cast(ulong)(_payload6433.uuid.high); + *cast(ulong*)(_base6431 + (16+6*size_t.sizeof)) = cast(ulong)(_payload6433.uuid.low); + *cast(size_t*)(_base6431 + (24+7*size_t.sizeof)) = cast(size_t)(_payload6433.block.length); + *cast(void**)(_base6431 + (24+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6433.block.ptr)); + *cast(uint*)(_base6431 + (24+8*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6433.priority)); + *cast(uint*)(_base6431 + (28+8*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6433.unlockRequirement.context)); + *cast(uint*)(_base6431 + (32+8*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6433.recipeNetworkId)); + break; + } + case _Tag6452.shaped: { + ref wit.pumpkin.plugin.bedrock_packets.common.BedrockShapedRecipe _payload6443 = _elem6431.getShaped(); + *cast(ubyte*)(_base6431 + 0) = cast(ubyte)(1); + *cast(size_t*)(_base6431 + (8+1*size_t.sizeof)) = cast(size_t)(_payload6443.recipeId.length); + *cast(void**)(_base6431 + 8) = cast(void*)(cast(void*)(_payload6443.recipeId.ptr)); + *cast(uint*)(_base6431 + (8+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6443.width)); + *cast(uint*)(_base6431 + (12+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6443.height)); + auto _listSrc6445 = _payload6443.input; + auto _list6445 = _listSrc6445.length ? wit.common.malloc(_listSrc6445.length * ((8+2*size_t.sizeof))) : null; + assert(!_listSrc6445.length || _list6445); + foreach (_elem6444_idx, ref _elem6444; _listSrc6445) { + auto _base6444 = _list6445 + _elem6444_idx * ((8+2*size_t.sizeof)); + *cast(size_t*)(_base6444 + size_t.sizeof) = cast(size_t)(_elem6444.itemIdentifier.length); + *cast(void**)(_base6444 + 0) = cast(void*)(cast(void*)(_elem6444.itemIdentifier.ptr)); + *cast(uint*)(_base6444 + (2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6444.metadataValue)); + *cast(uint*)(_base6444 + (4+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6444.count)); + + } + if (_listSrc6445.length) wit.common.free(_listSrc6445.ptr); + *cast(size_t*)(_base6431 + (16+3*size_t.sizeof)) = cast(size_t)(_payload6443.input.length); + *cast(void**)(_base6431 + (16+2*size_t.sizeof)) = cast(void*)(_list6445); + auto _listSrc6451 = _payload6443.output; + auto _list6451 = _listSrc6451.length ? wit.common.malloc(_listSrc6451.length * ((24+6*size_t.sizeof))) : null; + assert(!_listSrc6451.length || _list6451); + foreach (_elem6446_idx, ref _elem6446; _listSrc6451) { + auto _base6446 = _list6451 + _elem6446_idx * ((24+6*size_t.sizeof)); + *cast(uint*)(_base6446 + 0) = cast(uint)(cast(uint)(_elem6446.id)); + *cast(uint*)(_base6446 + 4) = cast(uint)(cast(uint)(_elem6446.stackSize)); + *cast(uint*)(_base6446 + 8) = cast(uint)(cast(uint)(_elem6446.auxValue)); + *cast(uint*)(_base6446 + 12) = cast(uint)(cast(uint)(_elem6446.blockRuntimeId)); + *cast(size_t*)(_base6446 + (16+1*size_t.sizeof)) = cast(size_t)(_elem6446.nbtData.length); + *cast(void**)(_base6446 + 16) = cast(void*)(cast(void*)(_elem6446.nbtData.ptr)); + auto _listSrc6448 = _elem6446.placeOnBlocks; + auto _list6448 = _listSrc6448.length ? wit.common.malloc(_listSrc6448.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc6448.length || _list6448); + foreach (_elem6447_idx, ref _elem6447; _listSrc6448) { + auto _base6447 = _list6448 + _elem6447_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6447 + size_t.sizeof) = cast(size_t)(_elem6447.length); + *cast(void**)(_base6447 + 0) = cast(void*)(cast(void*)(_elem6447.ptr)); + + } + if (_listSrc6448.length) wit.common.free(_listSrc6448.ptr); + *cast(size_t*)(_base6446 + (16+3*size_t.sizeof)) = cast(size_t)(_elem6446.placeOnBlocks.length); + *cast(void**)(_base6446 + (16+2*size_t.sizeof)) = cast(void*)(_list6448); + auto _listSrc6450 = _elem6446.destroyBlocks; + auto _list6450 = _listSrc6450.length ? wit.common.malloc(_listSrc6450.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc6450.length || _list6450); + foreach (_elem6449_idx, ref _elem6449; _listSrc6450) { + auto _base6449 = _list6450 + _elem6449_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6449 + size_t.sizeof) = cast(size_t)(_elem6449.length); + *cast(void**)(_base6449 + 0) = cast(void*)(cast(void*)(_elem6449.ptr)); + + } + if (_listSrc6450.length) wit.common.free(_listSrc6450.ptr); + *cast(size_t*)(_base6446 + (16+5*size_t.sizeof)) = cast(size_t)(_elem6446.destroyBlocks.length); + *cast(void**)(_base6446 + (16+4*size_t.sizeof)) = cast(void*)(_list6450); + *cast(ulong*)(_base6446 + (16+6*size_t.sizeof)) = cast(ulong)(cast(ulong)(_elem6446.shieldBlockingTick)); + + } + if (_listSrc6451.length) wit.common.free(_listSrc6451.ptr); + *cast(size_t*)(_base6431 + (16+5*size_t.sizeof)) = cast(size_t)(_payload6443.output.length); + *cast(void**)(_base6431 + (16+4*size_t.sizeof)) = cast(void*)(_list6451); + *cast(ulong*)(_base6431 + (16+6*size_t.sizeof)) = cast(ulong)(_payload6443.uuid.high); + *cast(ulong*)(_base6431 + (24+6*size_t.sizeof)) = cast(ulong)(_payload6443.uuid.low); + *cast(size_t*)(_base6431 + (32+7*size_t.sizeof)) = cast(size_t)(_payload6443.block.length); + *cast(void**)(_base6431 + (32+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6443.block.ptr)); + *cast(uint*)(_base6431 + (32+8*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6443.priority)); + *cast(ubyte*)(_base6431 + (36+8*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6443.assumeSymmetry)); + *cast(uint*)(_base6431 + (40+8*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6443.unlockRequirement.context)); + *cast(uint*)(_base6431 + (44+8*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6443.recipeNetworkId)); + break; + } + } + + } + if (_listSrc6453.length) wit.common.free(_listSrc6453.ptr); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6430.recipes.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(_list6453); + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6430.cleanRecipes)); + break; + } + case _Tag6654.cCreativeContent: { + ref wit.pumpkin.plugin.bedrock_packets.common.CCreativeContent _payload6455 = _payload6352.getCCreativeContent(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(14); + auto _listSrc6461 = _payload6455.groups; + auto _list6461 = _listSrc6461.length ? wit.common.malloc(_listSrc6461.length * ((32+8*size_t.sizeof))) : null; + assert(!_listSrc6461.length || _list6461); + foreach (_elem6456_idx, ref _elem6456; _listSrc6461) { + auto _base6456 = _list6461 + _elem6456_idx * ((32+8*size_t.sizeof)); + *cast(ubyte*)(_base6456 + 0) = cast(ubyte)(cast(uint)(_elem6456.creativeCategory)); + *cast(size_t*)(_base6456 + (2*size_t.sizeof)) = cast(size_t)(_elem6456.name.length); + *cast(void**)(_base6456 + size_t.sizeof) = cast(void*)(cast(void*)(_elem6456.name.ptr)); + *cast(uint*)(_base6456 + (8+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6456.groupIconItem.id)); + *cast(uint*)(_base6456 + (12+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6456.groupIconItem.stackSize)); + *cast(uint*)(_base6456 + (16+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6456.groupIconItem.auxValue)); + *cast(uint*)(_base6456 + (20+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6456.groupIconItem.blockRuntimeId)); + *cast(size_t*)(_base6456 + (24+3*size_t.sizeof)) = cast(size_t)(_elem6456.groupIconItem.nbtData.length); + *cast(void**)(_base6456 + (24+2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6456.groupIconItem.nbtData.ptr)); + auto _listSrc6458 = _elem6456.groupIconItem.placeOnBlocks; + auto _list6458 = _listSrc6458.length ? wit.common.malloc(_listSrc6458.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc6458.length || _list6458); + foreach (_elem6457_idx, ref _elem6457; _listSrc6458) { + auto _base6457 = _list6458 + _elem6457_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6457 + size_t.sizeof) = cast(size_t)(_elem6457.length); + *cast(void**)(_base6457 + 0) = cast(void*)(cast(void*)(_elem6457.ptr)); + + } + if (_listSrc6458.length) wit.common.free(_listSrc6458.ptr); + *cast(size_t*)(_base6456 + (24+5*size_t.sizeof)) = cast(size_t)(_elem6456.groupIconItem.placeOnBlocks.length); + *cast(void**)(_base6456 + (24+4*size_t.sizeof)) = cast(void*)(_list6458); + auto _listSrc6460 = _elem6456.groupIconItem.destroyBlocks; + auto _list6460 = _listSrc6460.length ? wit.common.malloc(_listSrc6460.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc6460.length || _list6460); + foreach (_elem6459_idx, ref _elem6459; _listSrc6460) { + auto _base6459 = _list6460 + _elem6459_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6459 + size_t.sizeof) = cast(size_t)(_elem6459.length); + *cast(void**)(_base6459 + 0) = cast(void*)(cast(void*)(_elem6459.ptr)); + + } + if (_listSrc6460.length) wit.common.free(_listSrc6460.ptr); + *cast(size_t*)(_base6456 + (24+7*size_t.sizeof)) = cast(size_t)(_elem6456.groupIconItem.destroyBlocks.length); + *cast(void**)(_base6456 + (24+6*size_t.sizeof)) = cast(void*)(_list6460); + *cast(ulong*)(_base6456 + (24+8*size_t.sizeof)) = cast(ulong)(cast(ulong)(_elem6456.groupIconItem.shieldBlockingTick)); + + } + if (_listSrc6461.length) wit.common.free(_listSrc6461.ptr); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6455.groups.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(_list6461); + auto _listSrc6467 = _payload6455.entries; + auto _list6467 = _listSrc6467.length ? wit.common.malloc(_listSrc6467.length * ((40+6*size_t.sizeof))) : null; + assert(!_listSrc6467.length || _list6467); + foreach (_elem6462_idx, ref _elem6462; _listSrc6467) { + auto _base6462 = _list6467 + _elem6462_idx * ((40+6*size_t.sizeof)); + *cast(uint*)(_base6462 + 0) = cast(uint)(cast(uint)(_elem6462.id)); + *cast(uint*)(_base6462 + 8) = cast(uint)(cast(uint)(_elem6462.item.id)); + *cast(uint*)(_base6462 + 12) = cast(uint)(cast(uint)(_elem6462.item.stackSize)); + *cast(uint*)(_base6462 + 16) = cast(uint)(cast(uint)(_elem6462.item.auxValue)); + *cast(uint*)(_base6462 + 20) = cast(uint)(cast(uint)(_elem6462.item.blockRuntimeId)); + *cast(size_t*)(_base6462 + (24+1*size_t.sizeof)) = cast(size_t)(_elem6462.item.nbtData.length); + *cast(void**)(_base6462 + 24) = cast(void*)(cast(void*)(_elem6462.item.nbtData.ptr)); + auto _listSrc6464 = _elem6462.item.placeOnBlocks; + auto _list6464 = _listSrc6464.length ? wit.common.malloc(_listSrc6464.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc6464.length || _list6464); + foreach (_elem6463_idx, ref _elem6463; _listSrc6464) { + auto _base6463 = _list6464 + _elem6463_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6463 + size_t.sizeof) = cast(size_t)(_elem6463.length); + *cast(void**)(_base6463 + 0) = cast(void*)(cast(void*)(_elem6463.ptr)); + + } + if (_listSrc6464.length) wit.common.free(_listSrc6464.ptr); + *cast(size_t*)(_base6462 + (24+3*size_t.sizeof)) = cast(size_t)(_elem6462.item.placeOnBlocks.length); + *cast(void**)(_base6462 + (24+2*size_t.sizeof)) = cast(void*)(_list6464); + auto _listSrc6466 = _elem6462.item.destroyBlocks; + auto _list6466 = _listSrc6466.length ? wit.common.malloc(_listSrc6466.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc6466.length || _list6466); + foreach (_elem6465_idx, ref _elem6465; _listSrc6466) { + auto _base6465 = _list6466 + _elem6465_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6465 + size_t.sizeof) = cast(size_t)(_elem6465.length); + *cast(void**)(_base6465 + 0) = cast(void*)(cast(void*)(_elem6465.ptr)); + + } + if (_listSrc6466.length) wit.common.free(_listSrc6466.ptr); + *cast(size_t*)(_base6462 + (24+5*size_t.sizeof)) = cast(size_t)(_elem6462.item.destroyBlocks.length); + *cast(void**)(_base6462 + (24+4*size_t.sizeof)) = cast(void*)(_list6466); + *cast(ulong*)(_base6462 + (24+6*size_t.sizeof)) = cast(ulong)(cast(ulong)(_elem6462.item.shieldBlockingTick)); + *cast(uint*)(_base6462 + (32+6*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6462.groupIndex)); + + } + if (_listSrc6467.length) wit.common.free(_listSrc6467.ptr); + *cast(size_t*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(size_t)(_payload6455.entries.length); + *cast(void**)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(void*)(_list6467); + break; + } + case _Tag6654.cDisconnect: { + ref wit.pumpkin.plugin.bedrock_packets.common.CDisconnect _payload6469 = _payload6352.getCDisconnect(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(15); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6469.reason)); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(cast(uint)(_payload6469.skipMessage)); + *cast(size_t*)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(size_t)(_payload6469.message.length); + *cast(void**)(_retArea.ptr + 40) = cast(void*)(cast(void*)(_payload6469.message.ptr)); + *cast(size_t*)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(size_t)(_payload6469.filteredMessage.length); + *cast(void**)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6469.filteredMessage.ptr)); + break; + } + case _Tag6654.cGamerulesChanged: { + ref wit.pumpkin.plugin.bedrock_packets.common.CGamerulesChanged _payload6471 = _payload6352.getCGamerulesChanged(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(16); + auto _listSrc6473 = _payload6471.ruleData; + auto _list6473 = _listSrc6473.length ? wit.common.malloc(_listSrc6473.length * ((3*size_t.sizeof))) : null; + assert(!_listSrc6473.length || _list6473); + foreach (_elem6472_idx, ref _elem6472; _listSrc6473) { + auto _base6472 = _list6473 + _elem6472_idx * ((3*size_t.sizeof)); + *cast(size_t*)(_base6472 + size_t.sizeof) = cast(size_t)(_elem6472.ruleName.length); + *cast(void**)(_base6472 + 0) = cast(void*)(cast(void*)(_elem6472.ruleName.ptr)); + *cast(ubyte*)(_base6472 + (2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6472.ruleCanBeModified)); + *cast(ubyte*)(_base6472 + (1+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6472.ruleValue)); + + } + if (_listSrc6473.length) wit.common.free(_listSrc6473.ptr); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6471.ruleData.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(_list6473); + break; + } + case _Tag6654.cInventoryContent: { + ref wit.pumpkin.plugin.bedrock_packets.common.CInventoryContent _payload6475 = _payload6352.getCInventoryContent(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(17); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6475.containerId)); + auto _listSrc6481 = _payload6475.slots; + auto _list6481 = _listSrc6481.length ? wit.common.malloc(_listSrc6481.length * ((24+2*size_t.sizeof))) : null; + assert(!_listSrc6481.length || _list6481); + foreach (_elem6476_idx, ref _elem6476; _listSrc6481) { + auto _base6476 = _list6481 + _elem6476_idx * ((24+2*size_t.sizeof)); + *cast(uint*)(_base6476 + 0) = cast(uint)(cast(uint)(_elem6476.id)); + *cast(uint*)(_base6476 + 4) = cast(uint)(cast(uint)(_elem6476.stackSize)); + *cast(uint*)(_base6476 + 8) = cast(uint)(cast(uint)(_elem6476.auxValue)); + *cast(uint*)(_base6476 + 12) = cast(uint)(cast(uint)(_elem6476.blockRuntimeId)); + *cast(size_t*)(_base6476 + (16+1*size_t.sizeof)) = cast(size_t)(_elem6476.extraData.length); + *cast(void**)(_base6476 + 16) = cast(void*)(cast(void*)(_elem6476.extraData.ptr)); + if (_elem6476.netId.isSome) { + ref _payload6480 = _elem6476.netId.unwrap(); + *cast(ubyte*)(_base6476 + (16+2*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base6476 + (20+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6480)); + } else { + *cast(ubyte*)(_base6476 + (16+2*size_t.sizeof)) = cast(ubyte)(0); + } + + } + if (_listSrc6481.length) wit.common.free(_listSrc6481.ptr); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload6475.slots.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(_list6481); + *cast(ubyte*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6475.fullContainerName.containerName)); + if (_payload6475.fullContainerName.dynamicId.isSome) { + ref _payload6485 = _payload6475.fullContainerName.dynamicId.unwrap(); + *cast(ubyte*)(_retArea.ptr + (36+3*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6485)); + } else { + *cast(ubyte*)(_retArea.ptr + (36+3*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(uint*)(_retArea.ptr + (40+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6475.storageItem.id)); + *cast(uint*)(_retArea.ptr + (44+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6475.storageItem.stackSize)); + *cast(uint*)(_retArea.ptr + (48+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6475.storageItem.auxValue)); + *cast(uint*)(_retArea.ptr + (52+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6475.storageItem.blockRuntimeId)); + *cast(size_t*)(_retArea.ptr + (56+5*size_t.sizeof)) = cast(size_t)(_payload6475.storageItem.extraData.length); + *cast(void**)(_retArea.ptr + (56+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6475.storageItem.extraData.ptr)); + if (_payload6475.storageItem.netId.isSome) { + ref _payload6489 = _payload6475.storageItem.netId.unwrap(); + *cast(ubyte*)(_retArea.ptr + (56+6*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (60+6*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6489)); + } else { + *cast(ubyte*)(_retArea.ptr + (56+6*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag6654.cInventorySlot: { + ref wit.pumpkin.plugin.bedrock_packets.common.CInventorySlot _payload6491 = _payload6352.getCInventorySlot(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(18); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6491.containerId)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6491.slot)); + if (_payload6491.fullContainerName.isSome) { + ref _payload6495 = _payload6491.fullContainerName.unwrap(); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(1); + *cast(ubyte*)(_retArea.ptr + 44) = cast(ubyte)(cast(uint)(_payload6495.containerName)); + if (_payload6495.dynamicId.isSome) { + ref _payload6499 = _payload6495.dynamicId.unwrap(); + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 52) = cast(uint)(cast(uint)(_payload6499)); + } else { + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(0); + } + } else { + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(0); + } + if (_payload6491.storageItem.isSome) { + ref _payload6503 = _payload6491.storageItem.unwrap(); + *cast(ubyte*)(_retArea.ptr + 56) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (56+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6503.id)); + *cast(uint*)(_retArea.ptr + (60+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6503.stackSize)); + *cast(uint*)(_retArea.ptr + (64+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6503.auxValue)); + *cast(uint*)(_retArea.ptr + (68+1*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6503.blockRuntimeId)); + *cast(size_t*)(_retArea.ptr + (72+2*size_t.sizeof)) = cast(size_t)(_payload6503.extraData.length); + *cast(void**)(_retArea.ptr + (72+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6503.extraData.ptr)); + if (_payload6503.netId.isSome) { + ref _payload6507 = _payload6503.netId.unwrap(); + *cast(ubyte*)(_retArea.ptr + (72+3*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (76+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6507)); + } else { + *cast(ubyte*)(_retArea.ptr + (72+3*size_t.sizeof)) = cast(ubyte)(0); + } + } else { + *cast(ubyte*)(_retArea.ptr + 56) = cast(ubyte)(0); + } + *cast(uint*)(_retArea.ptr + (80+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6491.item.id)); + *cast(uint*)(_retArea.ptr + (84+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6491.item.stackSize)); + *cast(uint*)(_retArea.ptr + (88+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6491.item.auxValue)); + *cast(uint*)(_retArea.ptr + (92+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6491.item.blockRuntimeId)); + *cast(size_t*)(_retArea.ptr + (96+4*size_t.sizeof)) = cast(size_t)(_payload6491.item.extraData.length); + *cast(void**)(_retArea.ptr + (96+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6491.item.extraData.ptr)); + if (_payload6491.item.netId.isSome) { + ref _payload6511 = _payload6491.item.netId.unwrap(); + *cast(ubyte*)(_retArea.ptr + (96+5*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (100+5*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6511)); + } else { + *cast(ubyte*)(_retArea.ptr + (96+5*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag6654.cItemRegistry: { + ref wit.pumpkin.plugin.bedrock_packets.common.CItemRegistry _payload6513 = _payload6352.getCItemRegistry(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(19); + auto _listSrc6515 = _payload6513.items; + auto _list6515 = _listSrc6515.length ? wit.common.malloc(_listSrc6515.length * ((8+5*size_t.sizeof))) : null; + assert(!_listSrc6515.length || _list6515); + foreach (_elem6514_idx, ref _elem6514; _listSrc6515) { + auto _base6514 = _list6515 + _elem6514_idx * ((8+5*size_t.sizeof)); + *cast(size_t*)(_base6514 + size_t.sizeof) = cast(size_t)(_elem6514.itemName.length); + *cast(void**)(_base6514 + 0) = cast(void*)(cast(void*)(_elem6514.itemName.ptr)); + *cast(uint*)(_base6514 + (2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6514.itemId)); + *cast(ubyte*)(_base6514 + (4+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6514.isComponentBased)); + *cast(uint*)(_base6514 + (8+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6514.itemVersion)); + *cast(size_t*)(_base6514 + (8+4*size_t.sizeof)) = cast(size_t)(_elem6514.componentData.length); + *cast(void**)(_base6514 + (8+3*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6514.componentData.ptr)); + + } + if (_listSrc6515.length) wit.common.free(_listSrc6515.ptr); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6513.items.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(_list6515); + break; + } + case _Tag6654.cItemStackResponse: { + ref wit.pumpkin.plugin.bedrock_packets.common.CItemStackResponse _payload6517 = _payload6352.getCItemStackResponse(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(20); + auto _listSrc6527 = _payload6517.responses; + auto _list6527 = _listSrc6527.length ? wit.common.malloc(_listSrc6527.length * ((8+2*size_t.sizeof))) : null; + assert(!_listSrc6527.length || _list6527); + foreach (_elem6518_idx, ref _elem6518; _listSrc6527) { + auto _base6518 = _list6527 + _elem6518_idx * ((8+2*size_t.sizeof)); + *cast(ubyte*)(_base6518 + 0) = cast(ubyte)(cast(uint)(_elem6518.result)); + *cast(uint*)(_base6518 + 4) = cast(uint)(cast(uint)(_elem6518.clientRequestId)); + auto _listSrc6526 = _elem6518.containers; + auto _list6526 = _listSrc6526.length ? wit.common.malloc(_listSrc6526.length * ((8+3*size_t.sizeof))) : null; + assert(!_listSrc6526.length || _list6526); + foreach (_elem6519_idx, ref _elem6519; _listSrc6526) { + auto _base6519 = _list6526 + _elem6519_idx * ((8+3*size_t.sizeof)); + *cast(ubyte*)(_base6519 + 0) = cast(ubyte)(cast(uint)(_elem6519.fullContainerName.containerName)); + if (_elem6519.fullContainerName.dynamicId.isSome) { + ref _payload6523 = _elem6519.fullContainerName.dynamicId.unwrap(); + *cast(ubyte*)(_base6519 + 4) = cast(ubyte)(1); + *cast(uint*)(_base6519 + 8) = cast(uint)(cast(uint)(_payload6523)); + } else { + *cast(ubyte*)(_base6519 + 4) = cast(ubyte)(0); + } + auto _listSrc6525 = _elem6519.slots; + auto _list6525 = _listSrc6525.length ? wit.common.malloc(_listSrc6525.length * ((8+5*size_t.sizeof))) : null; + assert(!_listSrc6525.length || _list6525); + foreach (_elem6524_idx, ref _elem6524; _listSrc6525) { + auto _base6524 = _list6525 + _elem6524_idx * ((8+5*size_t.sizeof)); + *cast(ubyte*)(_base6524 + 0) = cast(ubyte)(cast(uint)(_elem6524.requestedSlot)); + *cast(ubyte*)(_base6524 + 1) = cast(ubyte)(cast(uint)(_elem6524.slot)); + *cast(ubyte*)(_base6524 + 2) = cast(ubyte)(cast(uint)(_elem6524.amount)); + *cast(uint*)(_base6524 + 4) = cast(uint)(cast(uint)(_elem6524.itemStackNetId)); + *cast(size_t*)(_base6524 + (8+1*size_t.sizeof)) = cast(size_t)(_elem6524.customName.length); + *cast(void**)(_base6524 + 8) = cast(void*)(cast(void*)(_elem6524.customName.ptr)); + *cast(size_t*)(_base6524 + (8+3*size_t.sizeof)) = cast(size_t)(_elem6524.filteredCustomName.length); + *cast(void**)(_base6524 + (8+2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6524.filteredCustomName.ptr)); + *cast(uint*)(_base6524 + (8+4*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6524.durabilityCorrection)); + + } + if (_listSrc6525.length) wit.common.free(_listSrc6525.ptr); + *cast(size_t*)(_base6519 + (8+2*size_t.sizeof)) = cast(size_t)(_elem6519.slots.length); + *cast(void**)(_base6519 + (8+1*size_t.sizeof)) = cast(void*)(_list6525); + + } + if (_listSrc6526.length) wit.common.free(_listSrc6526.ptr); + *cast(size_t*)(_base6518 + (8+1*size_t.sizeof)) = cast(size_t)(_elem6518.containers.length); + *cast(void**)(_base6518 + 8) = cast(void*)(_list6526); + + } + if (_listSrc6527.length) wit.common.free(_listSrc6527.ptr); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6517.responses.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(_list6527); + break; + } + case _Tag6654.cLevelChunk: { + ref wit.pumpkin.plugin.bedrock_packets.common.CLevelChunk _payload6529 = _payload6352.getCLevelChunk(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(21); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6529.dimension)); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(cast(uint)(_payload6529.cacheEnabled)); + *cast(size_t*)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(size_t)(_payload6529.chunk.length); + *cast(void**)(_retArea.ptr + 40) = cast(void*)(cast(void*)(_payload6529.chunk.ptr)); + auto _listSrc6531 = _payload6529.blockActors; + auto _list6531 = _listSrc6531.length ? wit.common.malloc(_listSrc6531.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc6531.length || _list6531); + foreach (_elem6530_idx, ref _elem6530; _listSrc6531) { + auto _base6530 = _list6531 + _elem6530_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6530 + size_t.sizeof) = cast(size_t)(_elem6530.length); + *cast(void**)(_base6530 + 0) = cast(void*)(cast(void*)(_elem6530.ptr)); + + } + if (_listSrc6531.length) wit.common.free(_listSrc6531.ptr); + *cast(size_t*)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(size_t)(_payload6529.blockActors.length); + *cast(void**)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(void*)(_list6531); + break; + } + case _Tag6654.cLevelEvent: { + ref wit.pumpkin.plugin.bedrock_packets.common.CLevelEvent _payload6533 = _payload6352.getCLevelEvent(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(22); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6533.eventId)); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload6533.position[0]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload6533.position[1]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload6533.position[2]); + *cast(uint*)(_retArea.ptr + 64) = cast(uint)(cast(uint)(_payload6533.data)); + break; + } + case _Tag6654.cLevelSoundEvent: { + ref wit.pumpkin.plugin.bedrock_packets.common.CLevelSoundEvent _payload6535 = _payload6352.getCLevelSoundEvent(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(23); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6535.soundEvent.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6535.soundEvent.ptr)); + *cast(double*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(double)(_payload6535.position[0]); + *cast(double*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(double)(_payload6535.position[1]); + *cast(double*)(_retArea.ptr + (48+2*size_t.sizeof)) = cast(double)(_payload6535.position[2]); + *cast(uint*)(_retArea.ptr + (56+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6535.data)); + *cast(size_t*)(_retArea.ptr + (56+4*size_t.sizeof)) = cast(size_t)(_payload6535.actorIdentifier.length); + *cast(void**)(_retArea.ptr + (56+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6535.actorIdentifier.ptr)); + *cast(ubyte*)(_retArea.ptr + (56+5*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6535.isBaby)); + *cast(ubyte*)(_retArea.ptr + (57+5*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6535.isGlobal)); + *cast(ulong*)(_retArea.ptr + (56+6*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload6535.actorUniqueId)); + if (_payload6535.fireAtPosition.isSome) { + ref _payload6539 = _payload6535.fireAtPosition.unwrap(); + *cast(ubyte*)(_retArea.ptr + (64+6*size_t.sizeof)) = cast(ubyte)(1); + *cast(double*)(_retArea.ptr + (72+6*size_t.sizeof)) = cast(double)(_payload6539[0]); + *cast(double*)(_retArea.ptr + (80+6*size_t.sizeof)) = cast(double)(_payload6539[1]); + *cast(double*)(_retArea.ptr + (88+6*size_t.sizeof)) = cast(double)(_payload6539[2]); + } else { + *cast(ubyte*)(_retArea.ptr + (64+6*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag6654.cMobEffect: { + ref wit.pumpkin.plugin.bedrock_packets.common.CMobEffect _payload6541 = _payload6352.getCMobEffect(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(24); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload6541.targetRuntimeId)); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(cast(uint)(_payload6541.eventId)); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload6541.effectId)); + *cast(uint*)(_retArea.ptr + 48) = cast(uint)(cast(uint)(_payload6541.effectAmplifier)); + *cast(ubyte*)(_retArea.ptr + 52) = cast(ubyte)(cast(uint)(_payload6541.showParticles)); + *cast(uint*)(_retArea.ptr + 56) = cast(uint)(cast(uint)(_payload6541.effectDurationTicks)); + *cast(ulong*)(_retArea.ptr + 64) = cast(ulong)(cast(ulong)(_payload6541.tick)); + *cast(ubyte*)(_retArea.ptr + 72) = cast(ubyte)(cast(uint)(_payload6541.ambient)); + break; + } + case _Tag6654.cMobEquipment: { + ref wit.pumpkin.plugin.bedrock_packets.common.CMobEquipment _payload6543 = _payload6352.getCMobEquipment(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(25); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload6543.targetRuntimeId)); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload6543.item.id)); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload6543.item.stackSize)); + *cast(uint*)(_retArea.ptr + 48) = cast(uint)(cast(uint)(_payload6543.item.auxValue)); + *cast(uint*)(_retArea.ptr + 52) = cast(uint)(cast(uint)(_payload6543.item.blockRuntimeId)); + *cast(size_t*)(_retArea.ptr + (56+1*size_t.sizeof)) = cast(size_t)(_payload6543.item.extraData.length); + *cast(void**)(_retArea.ptr + 56) = cast(void*)(cast(void*)(_payload6543.item.extraData.ptr)); + if (_payload6543.item.netId.isSome) { + ref _payload6547 = _payload6543.item.netId.unwrap(); + *cast(ubyte*)(_retArea.ptr + (56+2*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (60+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6547)); + } else { + *cast(ubyte*)(_retArea.ptr + (56+2*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + (64+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6543.slot)); + *cast(ubyte*)(_retArea.ptr + (65+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6543.selectedSlot)); + *cast(ubyte*)(_retArea.ptr + (66+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6543.containerId)); + break; + } + case _Tag6654.cModalFormRequest: { + ref wit.pumpkin.plugin.bedrock_packets.common.CModalFormRequest _payload6549 = _payload6352.getCModalFormRequest(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(26); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6549.formId)); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload6549.formUiJson.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6549.formUiJson.ptr)); + break; + } + case _Tag6654.cMoveActorAbsolute: { + ref wit.pumpkin.plugin.bedrock_packets.common.CMoveActorAbsolute _payload6551 = _payload6352.getCMoveActorAbsolute(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(27); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload6551.actorRuntimeId)); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(cast(uint)(_payload6551.header)); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload6551.position[0]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload6551.position[1]); + *cast(double*)(_retArea.ptr + 64) = cast(double)(_payload6551.position[2]); + *cast(ubyte*)(_retArea.ptr + 72) = cast(ubyte)(cast(uint)(_payload6551.rotationX)); + *cast(ubyte*)(_retArea.ptr + 73) = cast(ubyte)(cast(uint)(_payload6551.rotationY)); + *cast(ubyte*)(_retArea.ptr + 74) = cast(ubyte)(cast(uint)(_payload6551.rotationYHead)); + break; + } + case _Tag6654.cMoveActorDelta: { + ref wit.pumpkin.plugin.bedrock_packets.common.CMoveActorDelta _payload6553 = _payload6352.getCMoveActorDelta(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(28); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload6553.entityRuntimeId)); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload6553.flags)); + *cast(float*)(_retArea.ptr + 44) = cast(float)(_payload6553.x); + *cast(float*)(_retArea.ptr + 48) = cast(float)(_payload6553.y); + *cast(float*)(_retArea.ptr + 52) = cast(float)(_payload6553.z); + *cast(ubyte*)(_retArea.ptr + 56) = cast(ubyte)(cast(uint)(_payload6553.pitch)); + *cast(ubyte*)(_retArea.ptr + 57) = cast(ubyte)(cast(uint)(_payload6553.yaw)); + *cast(ubyte*)(_retArea.ptr + 58) = cast(ubyte)(cast(uint)(_payload6553.headYaw)); + break; + } + case _Tag6654.cMovePlayer: { + ref wit.pumpkin.plugin.bedrock_packets.common.CMovePlayer _payload6555 = _payload6352.getCMovePlayer(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(29); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload6555.playerRuntimeId)); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload6555.position[0]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload6555.position[1]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload6555.position[2]); + *cast(float*)(_retArea.ptr + 64) = cast(float)(_payload6555.pitch); + *cast(float*)(_retArea.ptr + 68) = cast(float)(_payload6555.yaw); + *cast(float*)(_retArea.ptr + 72) = cast(float)(_payload6555.headYaw); + *cast(ubyte*)(_retArea.ptr + 76) = cast(ubyte)(cast(uint)(_payload6555.mode)); + *cast(ubyte*)(_retArea.ptr + 77) = cast(ubyte)(cast(uint)(_payload6555.onGround)); + *cast(ulong*)(_retArea.ptr + 80) = cast(ulong)(cast(ulong)(_payload6555.ridingRuntimeId)); + *cast(uint*)(_retArea.ptr + 88) = cast(uint)(cast(uint)(_payload6555.teleportCause)); + *cast(uint*)(_retArea.ptr + 92) = cast(uint)(cast(uint)(_payload6555.teleportSourceEntityType)); + *cast(ulong*)(_retArea.ptr + 96) = cast(ulong)(cast(ulong)(_payload6555.tick)); + break; + } + case _Tag6654.cNetworkChunkPublisherUpdate: { + ref wit.pumpkin.plugin.bedrock_packets.common.CNetworkChunkPublisherUpdate _payload6557 = _payload6352.getCNetworkChunkPublisherUpdate(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(30); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6557.posForView[0])); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6557.posForView[1])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload6557.posForView[2])); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload6557.newRadius)); + *cast(size_t*)(_retArea.ptr + (48+1*size_t.sizeof)) = cast(size_t)(_payload6557.serverBuildChunkList.length); + *cast(void**)(_retArea.ptr + 48) = cast(void*)(cast(void*)(_payload6557.serverBuildChunkList.ptr)); + break; + } + case _Tag6654.cNetworkSettings: { + ref wit.pumpkin.plugin.bedrock_packets.common.CNetworkSettings _payload6559 = _payload6352.getCNetworkSettings(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(31); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6559.compressionThreshold)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6559.compressionAlgorithm)); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(cast(uint)(_payload6559.clientThrottleEnabled)); + *cast(ubyte*)(_retArea.ptr + 41) = cast(ubyte)(cast(uint)(_payload6559.clientThrottleThreshold)); + *cast(float*)(_retArea.ptr + 44) = cast(float)(_payload6559.clientThrottleScalar); + break; + } + case _Tag6654.cPlayStatus: { + ref wit.pumpkin.plugin.bedrock_packets.common.CPlayStatus _payload6561 = _payload6352.getCPlayStatus(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(32); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6561)); + break; + } + case _Tag6654.cPlayerHotbar: { + ref wit.pumpkin.plugin.bedrock_packets.common.CPlayerHotbar _payload6563 = _payload6352.getCPlayerHotbar(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(33); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6563.selectedSlot)); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(cast(uint)(_payload6563.containerId)); + *cast(ubyte*)(_retArea.ptr + 37) = cast(ubyte)(cast(uint)(_payload6563.shouldSelectSlot)); + break; + } + case _Tag6654.cPlayerList: { + ref wit.pumpkin.plugin.bedrock_packets.common.CPlayerList _payload6565 = _payload6352.getCPlayerList(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(34); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6565.action)); + auto _listSrc6573 = _payload6565.entries; + auto _list6573 = _listSrc6573.length ? wit.common.malloc(_listSrc6573.length * ((48+42*size_t.sizeof))) : null; + assert(!_listSrc6573.length || _list6573); + foreach (_elem6566_idx, ref _elem6566; _listSrc6573) { + auto _base6566 = _list6573 + _elem6566_idx * ((48+42*size_t.sizeof)); + *cast(ulong*)(_base6566 + 0) = cast(ulong)(_elem6566.uuid.high); + *cast(ulong*)(_base6566 + 8) = cast(ulong)(_elem6566.uuid.low); + *cast(ulong*)(_base6566 + 16) = cast(ulong)(cast(ulong)(_elem6566.entityUniqueId)); + *cast(size_t*)(_base6566 + (24+1*size_t.sizeof)) = cast(size_t)(_elem6566.username.length); + *cast(void**)(_base6566 + 24) = cast(void*)(cast(void*)(_elem6566.username.ptr)); + *cast(size_t*)(_base6566 + (24+3*size_t.sizeof)) = cast(size_t)(_elem6566.xuid.length); + *cast(void**)(_base6566 + (24+2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6566.xuid.ptr)); + *cast(size_t*)(_base6566 + (24+5*size_t.sizeof)) = cast(size_t)(_elem6566.platformChatId.length); + *cast(void**)(_base6566 + (24+4*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6566.platformChatId.ptr)); + *cast(ubyte*)(_base6566 + (24+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6566.buildPlatform)); + *cast(size_t*)(_base6566 + (24+8*size_t.sizeof)) = cast(size_t)(_elem6566.skin.skinId.length); + *cast(void**)(_base6566 + (24+7*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6566.skin.skinId.ptr)); + *cast(size_t*)(_base6566 + (24+10*size_t.sizeof)) = cast(size_t)(_elem6566.skin.playFabId.length); + *cast(void**)(_base6566 + (24+9*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6566.skin.playFabId.ptr)); + *cast(size_t*)(_base6566 + (24+12*size_t.sizeof)) = cast(size_t)(_elem6566.skin.resourcePatch.length); + *cast(void**)(_base6566 + (24+11*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6566.skin.resourcePatch.ptr)); + *cast(uint*)(_base6566 + (24+13*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6566.skin.imageWidth)); + *cast(uint*)(_base6566 + (28+13*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6566.skin.imageHeight)); + *cast(size_t*)(_base6566 + (32+14*size_t.sizeof)) = cast(size_t)(_elem6566.skin.skinData.length); + *cast(void**)(_base6566 + (32+13*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6566.skin.skinData.ptr)); + auto _listSrc6568 = _elem6566.skin.animations; + auto _list6568 = _listSrc6568.length ? wit.common.malloc(_listSrc6568.length * ((24+2*size_t.sizeof))) : null; + assert(!_listSrc6568.length || _list6568); + foreach (_elem6567_idx, ref _elem6567; _listSrc6568) { + auto _base6567 = _list6568 + _elem6567_idx * ((24+2*size_t.sizeof)); + *cast(double*)(_base6567 + 0) = cast(double)(_elem6567.frames); + *cast(size_t*)(_base6567 + (8+1*size_t.sizeof)) = cast(size_t)(_elem6567.image.length); + *cast(void**)(_base6567 + 8) = cast(void*)(cast(void*)(_elem6567.image.ptr)); + *cast(uint*)(_base6567 + (8+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6567.imageHeight)); + *cast(uint*)(_base6567 + (12+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6567.imageWidth)); + *cast(uint*)(_base6567 + (16+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6567.animationType)); + *cast(uint*)(_base6567 + (20+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6567.animationExpression)); + + } + if (_listSrc6568.length) wit.common.free(_listSrc6568.ptr); + *cast(size_t*)(_base6566 + (32+16*size_t.sizeof)) = cast(size_t)(_elem6566.skin.animations.length); + *cast(void**)(_base6566 + (32+15*size_t.sizeof)) = cast(void*)(_list6568); + *cast(uint*)(_base6566 + (32+17*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6566.skin.capeWidth)); + *cast(uint*)(_base6566 + (36+17*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6566.skin.capeHeight)); + *cast(size_t*)(_base6566 + (40+18*size_t.sizeof)) = cast(size_t)(_elem6566.skin.capeData.length); + *cast(void**)(_base6566 + (40+17*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6566.skin.capeData.ptr)); + *cast(size_t*)(_base6566 + (40+20*size_t.sizeof)) = cast(size_t)(_elem6566.skin.geometryData.length); + *cast(void**)(_base6566 + (40+19*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6566.skin.geometryData.ptr)); + *cast(size_t*)(_base6566 + (40+22*size_t.sizeof)) = cast(size_t)(_elem6566.skin.animationData.length); + *cast(void**)(_base6566 + (40+21*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6566.skin.animationData.ptr)); + *cast(size_t*)(_base6566 + (40+24*size_t.sizeof)) = cast(size_t)(_elem6566.skin.geometryDataEngineVersion.length); + *cast(void**)(_base6566 + (40+23*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6566.skin.geometryDataEngineVersion.ptr)); + *cast(size_t*)(_base6566 + (40+26*size_t.sizeof)) = cast(size_t)(_elem6566.skin.capeId.length); + *cast(void**)(_base6566 + (40+25*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6566.skin.capeId.ptr)); + *cast(size_t*)(_base6566 + (40+28*size_t.sizeof)) = cast(size_t)(_elem6566.skin.fullId.length); + *cast(void**)(_base6566 + (40+27*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6566.skin.fullId.ptr)); + *cast(size_t*)(_base6566 + (40+30*size_t.sizeof)) = cast(size_t)(_elem6566.skin.armSize.length); + *cast(void**)(_base6566 + (40+29*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6566.skin.armSize.ptr)); + *cast(size_t*)(_base6566 + (40+32*size_t.sizeof)) = cast(size_t)(_elem6566.skin.skinColor.length); + *cast(void**)(_base6566 + (40+31*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6566.skin.skinColor.ptr)); + auto _listSrc6570 = _elem6566.skin.personaPieces; + auto _list6570 = _listSrc6570.length ? wit.common.malloc(_listSrc6570.length * ((9*size_t.sizeof))) : null; + assert(!_listSrc6570.length || _list6570); + foreach (_elem6569_idx, ref _elem6569; _listSrc6570) { + auto _base6569 = _list6570 + _elem6569_idx * ((9*size_t.sizeof)); + *cast(ubyte*)(_base6569 + 0) = cast(ubyte)(cast(uint)(_elem6569.isDefault)); + *cast(size_t*)(_base6569 + (2*size_t.sizeof)) = cast(size_t)(_elem6569.packId.length); + *cast(void**)(_base6569 + size_t.sizeof) = cast(void*)(cast(void*)(_elem6569.packId.ptr)); + *cast(size_t*)(_base6569 + (4*size_t.sizeof)) = cast(size_t)(_elem6569.pieceId.length); + *cast(void**)(_base6569 + (3*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6569.pieceId.ptr)); + *cast(size_t*)(_base6569 + (6*size_t.sizeof)) = cast(size_t)(_elem6569.pieceType.length); + *cast(void**)(_base6569 + (5*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6569.pieceType.ptr)); + *cast(size_t*)(_base6569 + (8*size_t.sizeof)) = cast(size_t)(_elem6569.productId.length); + *cast(void**)(_base6569 + (7*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6569.productId.ptr)); + + } + if (_listSrc6570.length) wit.common.free(_listSrc6570.ptr); + *cast(size_t*)(_base6566 + (40+34*size_t.sizeof)) = cast(size_t)(_elem6566.skin.personaPieces.length); + *cast(void**)(_base6566 + (40+33*size_t.sizeof)) = cast(void*)(_list6570); + auto _listSrc6572 = _elem6566.skin.pieceTintColors; + auto _list6572 = _listSrc6572.length ? wit.common.malloc(_listSrc6572.length * ((4*size_t.sizeof))) : null; + assert(!_listSrc6572.length || _list6572); + foreach (_elem6571_idx, ref _elem6571; _listSrc6572) { + auto _base6571 = _list6572 + _elem6571_idx * ((4*size_t.sizeof)); + *cast(size_t*)(_base6571 + size_t.sizeof) = cast(size_t)(_elem6571.pieceType.length); + *cast(void**)(_base6571 + 0) = cast(void*)(cast(void*)(_elem6571.pieceType.ptr)); + *cast(size_t*)(_base6571 + (3*size_t.sizeof)) = cast(size_t)(_elem6571.colors.length); + *cast(void**)(_base6571 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6571.colors.ptr)); + + } + if (_listSrc6572.length) wit.common.free(_listSrc6572.ptr); + *cast(size_t*)(_base6566 + (40+36*size_t.sizeof)) = cast(size_t)(_elem6566.skin.pieceTintColors.length); + *cast(void**)(_base6566 + (40+35*size_t.sizeof)) = cast(void*)(_list6572); + *cast(ubyte*)(_base6566 + (40+37*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6566.skin.isPremium)); + *cast(ubyte*)(_base6566 + (41+37*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6566.skin.isPersona)); + *cast(ubyte*)(_base6566 + (42+37*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6566.skin.personaCapeOnClassic)); + *cast(ubyte*)(_base6566 + (43+37*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6566.skin.isPrimaryUser)); + *cast(ubyte*)(_base6566 + (44+37*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6566.skin.overrideAppearance)); + *cast(ubyte*)(_base6566 + (45+37*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6566.skin.isTrusted)); + *cast(size_t*)(_base6566 + (48+38*size_t.sizeof)) = cast(size_t)(_elem6566.skin.profileHash.length); + *cast(void**)(_base6566 + (48+37*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6566.skin.profileHash.ptr)); + *cast(ubyte*)(_base6566 + (48+39*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6566.isTeacher)); + *cast(ubyte*)(_base6566 + (49+39*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6566.isHost)); + *cast(ubyte*)(_base6566 + (50+39*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6566.isSubClient)); + *cast(size_t*)(_base6566 + (48+41*size_t.sizeof)) = cast(size_t)(_elem6566.playerColor.length); + *cast(void**)(_base6566 + (48+40*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6566.playerColor.ptr)); + + } + if (_listSrc6573.length) wit.common.free(_listSrc6573.ptr); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload6565.entries.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(_list6573); + break; + } + case _Tag6654.cRemoveActor: { + ref wit.pumpkin.plugin.bedrock_packets.common.CRemoveActor _payload6575 = _payload6352.getCRemoveActor(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(35); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload6575.targetActorId)); + break; + } + case _Tag6654.cRemoveObjective: { + ref wit.pumpkin.plugin.bedrock_packets.common.CRemoveObjective _payload6577 = _payload6352.getCRemoveObjective(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(36); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6577.objectiveName.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6577.objectiveName.ptr)); + break; + } + case _Tag6654.cResourcePackStackPacket: { + ref wit.pumpkin.plugin.bedrock_packets.common.CResourcePackStackPacket _payload6579 = _payload6352.getCResourcePackStackPacket(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(37); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6579.texturePackRequired)); + auto _listSrc6581 = _payload6579.texturePackList; + auto _list6581 = _listSrc6581.length ? wit.common.malloc(_listSrc6581.length * ((6*size_t.sizeof))) : null; + assert(!_listSrc6581.length || _list6581); + foreach (_elem6580_idx, ref _elem6580; _listSrc6581) { + auto _base6580 = _list6581 + _elem6580_idx * ((6*size_t.sizeof)); + *cast(size_t*)(_base6580 + size_t.sizeof) = cast(size_t)(_elem6580.packId.length); + *cast(void**)(_base6580 + 0) = cast(void*)(cast(void*)(_elem6580.packId.ptr)); + *cast(size_t*)(_base6580 + (3*size_t.sizeof)) = cast(size_t)(_elem6580.version_.length); + *cast(void**)(_base6580 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6580.version_.ptr)); + *cast(size_t*)(_base6580 + (5*size_t.sizeof)) = cast(size_t)(_elem6580.subPackName.length); + *cast(void**)(_base6580 + (4*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6580.subPackName.ptr)); + + } + if (_listSrc6581.length) wit.common.free(_listSrc6581.ptr); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload6579.texturePackList.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(_list6581); + *cast(size_t*)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(size_t)(_payload6579.baseGameVersion.length); + *cast(void**)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6579.baseGameVersion.ptr)); + auto _listSrc6583 = _payload6579.experiments.toggles; + auto _list6583 = _listSrc6583.length ? wit.common.malloc(_listSrc6583.length * ((3*size_t.sizeof))) : null; + assert(!_listSrc6583.length || _list6583); + foreach (_elem6582_idx, ref _elem6582; _listSrc6583) { + auto _base6582 = _list6583 + _elem6582_idx * ((3*size_t.sizeof)); + *cast(size_t*)(_base6582 + size_t.sizeof) = cast(size_t)(_elem6582.name.length); + *cast(void**)(_base6582 + 0) = cast(void*)(cast(void*)(_elem6582.name.ptr)); + *cast(ubyte*)(_base6582 + (2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6582.enabled)); + + } + if (_listSrc6583.length) wit.common.free(_listSrc6583.ptr); + *cast(size_t*)(_retArea.ptr + (32+6*size_t.sizeof)) = cast(size_t)(_payload6579.experiments.toggles.length); + *cast(void**)(_retArea.ptr + (32+5*size_t.sizeof)) = cast(void*)(_list6583); + *cast(ubyte*)(_retArea.ptr + (32+7*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6579.experiments.experimentsEverToggled)); + *cast(ubyte*)(_retArea.ptr + (32+8*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6579.includeEditorPacks)); + break; + } + case _Tag6654.cResourcePacksInfo: { + ref wit.pumpkin.plugin.bedrock_packets.common.CResourcePacksInfo _payload6585 = _payload6352.getCResourcePacksInfo(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(38); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6585.resourcePackRequired)); + *cast(ubyte*)(_retArea.ptr + 33) = cast(ubyte)(cast(uint)(_payload6585.hasAddonPacks)); + *cast(ubyte*)(_retArea.ptr + 34) = cast(ubyte)(cast(uint)(_payload6585.hasScripts)); + *cast(ubyte*)(_retArea.ptr + 35) = cast(ubyte)(cast(uint)(_payload6585.forceDisableVibrantVisuals)); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(_payload6585.worldTemplateIdAndVersion.packUuid.high); + *cast(ulong*)(_retArea.ptr + 48) = cast(ulong)(_payload6585.worldTemplateIdAndVersion.packUuid.low); + *cast(size_t*)(_retArea.ptr + (56+1*size_t.sizeof)) = cast(size_t)(_payload6585.worldTemplateIdAndVersion.packVersion.length); + *cast(void**)(_retArea.ptr + 56) = cast(void*)(cast(void*)(_payload6585.worldTemplateIdAndVersion.packVersion.ptr)); + auto _listSrc6587 = _payload6585.resourcePacks; + auto _list6587 = _listSrc6587.length ? wit.common.malloc(_listSrc6587.length * ((32+10*size_t.sizeof))) : null; + assert(!_listSrc6587.length || _list6587); + foreach (_elem6586_idx, ref _elem6586; _listSrc6587) { + auto _base6586 = _list6587 + _elem6586_idx * ((32+10*size_t.sizeof)); + *cast(ulong*)(_base6586 + 0) = cast(ulong)(_elem6586.packIdVersion.packUuid.high); + *cast(ulong*)(_base6586 + 8) = cast(ulong)(_elem6586.packIdVersion.packUuid.low); + *cast(size_t*)(_base6586 + (16+1*size_t.sizeof)) = cast(size_t)(_elem6586.packIdVersion.packVersion.length); + *cast(void**)(_base6586 + 16) = cast(void*)(cast(void*)(_elem6586.packIdVersion.packVersion.ptr)); + *cast(ulong*)(_base6586 + (16+2*size_t.sizeof)) = cast(ulong)(cast(ulong)(_elem6586.packSize)); + *cast(size_t*)(_base6586 + (24+3*size_t.sizeof)) = cast(size_t)(_elem6586.contentKey.length); + *cast(void**)(_base6586 + (24+2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6586.contentKey.ptr)); + *cast(size_t*)(_base6586 + (24+5*size_t.sizeof)) = cast(size_t)(_elem6586.subpackName.length); + *cast(void**)(_base6586 + (24+4*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6586.subpackName.ptr)); + *cast(size_t*)(_base6586 + (24+7*size_t.sizeof)) = cast(size_t)(_elem6586.contentIdentity.length); + *cast(void**)(_base6586 + (24+6*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6586.contentIdentity.ptr)); + *cast(ubyte*)(_base6586 + (24+8*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6586.hasScripts)); + *cast(ubyte*)(_base6586 + (25+8*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6586.isAddonPack)); + *cast(ubyte*)(_base6586 + (26+8*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6586.isRayTracingCapable)); + *cast(size_t*)(_base6586 + (24+10*size_t.sizeof)) = cast(size_t)(_elem6586.cdnUrl.length); + *cast(void**)(_base6586 + (24+9*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6586.cdnUrl.ptr)); + + } + if (_listSrc6587.length) wit.common.free(_listSrc6587.ptr); + *cast(size_t*)(_retArea.ptr + (56+3*size_t.sizeof)) = cast(size_t)(_payload6585.resourcePacks.length); + *cast(void**)(_retArea.ptr + (56+2*size_t.sizeof)) = cast(void*)(_list6587); + break; + } + case _Tag6654.cSetActorData: { + ref wit.pumpkin.plugin.bedrock_packets.common.CSetActorData _payload6589 = _payload6352.getCSetActorData(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(39); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload6589.targetRuntimeId)); + *cast(size_t*)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(size_t)(_payload6589.actorData.length); + *cast(void**)(_retArea.ptr + 40) = cast(void*)(cast(void*)(_payload6589.actorData.ptr)); + *cast(size_t*)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(size_t)(_payload6589.syncedProperties.intEntriesList.length); + *cast(void**)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6589.syncedProperties.intEntriesList.ptr)); + *cast(size_t*)(_retArea.ptr + (40+5*size_t.sizeof)) = cast(size_t)(_payload6589.syncedProperties.floatEntriesList.length); + *cast(void**)(_retArea.ptr + (40+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6589.syncedProperties.floatEntriesList.ptr)); + *cast(ulong*)(_retArea.ptr + (40+6*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload6589.tick)); + break; + } + case _Tag6654.cSetActorLink: { + ref wit.pumpkin.plugin.bedrock_packets.common.CSetActorLink _payload6591 = _payload6352.getCSetActorLink(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(40); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload6591.link.riddenUniqueId)); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(cast(ulong)(_payload6591.link.riderUniqueId)); + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(cast(uint)(_payload6591.link.linkType)); + *cast(ubyte*)(_retArea.ptr + 49) = cast(ubyte)(cast(uint)(_payload6591.link.immediate)); + *cast(ubyte*)(_retArea.ptr + 50) = cast(ubyte)(cast(uint)(_payload6591.link.riderInitiated)); + *cast(float*)(_retArea.ptr + 52) = cast(float)(_payload6591.link.vehicleAngularVelocity); + break; + } + case _Tag6654.cSetActorMotion: { + ref wit.pumpkin.plugin.bedrock_packets.common.CSetActorMotion _payload6593 = _payload6352.getCSetActorMotion(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(41); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload6593.targetRuntimeId)); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload6593.motion[0]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload6593.motion[1]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload6593.motion[2]); + *cast(ulong*)(_retArea.ptr + 64) = cast(ulong)(cast(ulong)(_payload6593.tick)); + break; + } + case _Tag6654.cSetDifficulty: { + ref wit.pumpkin.plugin.bedrock_packets.common.CSetDifficulty _payload6595 = _payload6352.getCSetDifficulty(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(42); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6595.difficulty)); + break; + } + case _Tag6654.cSetDisplayObjective: { + ref wit.pumpkin.plugin.bedrock_packets.common.CSetDisplayObjective _payload6597 = _payload6352.getCSetDisplayObjective(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(43); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6597.displaySlotName.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6597.displaySlotName.ptr)); + *cast(size_t*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(size_t)(_payload6597.objectiveName.length); + *cast(void**)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6597.objectiveName.ptr)); + *cast(size_t*)(_retArea.ptr + (32+5*size_t.sizeof)) = cast(size_t)(_payload6597.objectiveDisplayName.length); + *cast(void**)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6597.objectiveDisplayName.ptr)); + *cast(size_t*)(_retArea.ptr + (32+7*size_t.sizeof)) = cast(size_t)(_payload6597.criteriaName.length); + *cast(void**)(_retArea.ptr + (32+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6597.criteriaName.ptr)); + *cast(uint*)(_retArea.ptr + (32+8*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6597.sortOrder)); + break; + } + case _Tag6654.cSetHealth: { + ref wit.pumpkin.plugin.bedrock_packets.common.CSetHealth _payload6599 = _payload6352.getCSetHealth(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(44); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6599.health)); + break; + } + case _Tag6654.cSetPlayerGameType: { + ref wit.pumpkin.plugin.bedrock_packets.common.CSetPlayerGameType _payload6601 = _payload6352.getCSetPlayerGameType(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(45); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6601.playerGameType)); + break; + } + case _Tag6654.cSetScore: { + ref wit.pumpkin.plugin.bedrock_packets.common.CSetScore _payload6603 = _payload6352.getCSetScore(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(46); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6603.action)); + auto _listSrc6605 = _payload6603.entries; + auto _list6605 = _listSrc6605.length ? wit.common.malloc(_listSrc6605.length * ((24+4*size_t.sizeof))) : null; + assert(!_listSrc6605.length || _list6605); + foreach (_elem6604_idx, ref _elem6604; _listSrc6605) { + auto _base6604 = _list6605 + _elem6604_idx * ((24+4*size_t.sizeof)); + *cast(ulong*)(_base6604 + 0) = cast(ulong)(cast(ulong)(_elem6604.scoreboardId)); + *cast(size_t*)(_base6604 + (8+1*size_t.sizeof)) = cast(size_t)(_elem6604.objectiveName.length); + *cast(void**)(_base6604 + 8) = cast(void*)(cast(void*)(_elem6604.objectiveName.ptr)); + *cast(uint*)(_base6604 + (8+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6604.score)); + *cast(uint*)(_base6604 + (12+2*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6604.entryType)); + *cast(ulong*)(_base6604 + (16+2*size_t.sizeof)) = cast(ulong)(cast(ulong)(_elem6604.entityUniqueId)); + *cast(size_t*)(_base6604 + (24+3*size_t.sizeof)) = cast(size_t)(_elem6604.customName.length); + *cast(void**)(_base6604 + (24+2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6604.customName.ptr)); + + } + if (_listSrc6605.length) wit.common.free(_listSrc6605.ptr); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload6603.entries.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(_list6605); + break; + } + case _Tag6654.cSetSpawnPosition: { + ref wit.pumpkin.plugin.bedrock_packets.common.CSetSpawnPosition _payload6607 = _payload6352.getCSetSpawnPosition(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(47); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6607.spawnPositionType)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6607.blockPosition[0])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload6607.blockPosition[1])); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload6607.blockPosition[2])); + *cast(uint*)(_retArea.ptr + 48) = cast(uint)(cast(uint)(_payload6607.dimensionType)); + *cast(uint*)(_retArea.ptr + 52) = cast(uint)(cast(uint)(_payload6607.spawnBlockPos[0])); + *cast(uint*)(_retArea.ptr + 56) = cast(uint)(cast(uint)(_payload6607.spawnBlockPos[1])); + *cast(uint*)(_retArea.ptr + 60) = cast(uint)(cast(uint)(_payload6607.spawnBlockPos[2])); + break; + } + case _Tag6654.cSetTime: { + ref wit.pumpkin.plugin.bedrock_packets.common.CSetTime _payload6609 = _payload6352.getCSetTime(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(48); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6609.time)); + break; + } + case _Tag6654.cSetTitle: { + ref wit.pumpkin.plugin.bedrock_packets.common.CSetTitle _payload6611 = _payload6352.getCSetTitle(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(49); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6611.titleType)); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload6611.titleText.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6611.titleText.ptr)); + *cast(uint*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6611.fadeInTime)); + *cast(uint*)(_retArea.ptr + (36+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6611.stayTime)); + *cast(uint*)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6611.fadeOutTime)); + *cast(size_t*)(_retArea.ptr + (40+5*size_t.sizeof)) = cast(size_t)(_payload6611.xuid.length); + *cast(void**)(_retArea.ptr + (40+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6611.xuid.ptr)); + *cast(size_t*)(_retArea.ptr + (40+7*size_t.sizeof)) = cast(size_t)(_payload6611.platformOnlineId.length); + *cast(void**)(_retArea.ptr + (40+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6611.platformOnlineId.ptr)); + *cast(size_t*)(_retArea.ptr + (40+9*size_t.sizeof)) = cast(size_t)(_payload6611.filteredTitleMessage.length); + *cast(void**)(_retArea.ptr + (40+8*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6611.filteredTitleMessage.ptr)); + break; + } + case _Tag6654.cShowCredits: { + ref wit.pumpkin.plugin.bedrock_packets.common.CShowCredits _payload6613 = _payload6352.getCShowCredits(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(50); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload6613.playerRuntimeId)); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload6613.creditsState)); + break; + } + case _Tag6654.cStartGame: { + ref wit.pumpkin.plugin.bedrock_packets.common.CStartGame _payload6615 = _payload6352.getCStartGame(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(51); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload6615.entityId)); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(cast(ulong)(_payload6615.runtimeEntityId)); + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(cast(uint)(_payload6615.playerGamemode)); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload6615.position[0]); + *cast(double*)(_retArea.ptr + 64) = cast(double)(_payload6615.position[1]); + *cast(double*)(_retArea.ptr + 72) = cast(double)(_payload6615.position[2]); + *cast(float*)(_retArea.ptr + 80) = cast(float)(_payload6615.pitch); + *cast(float*)(_retArea.ptr + 84) = cast(float)(_payload6615.yaw); + *cast(ulong*)(_retArea.ptr + 88) = cast(ulong)(cast(ulong)(_payload6615.levelSettings.seed)); + *cast(uint*)(_retArea.ptr + 96) = cast(uint)(cast(uint)(_payload6615.levelSettings.spawnBiomeType)); + *cast(size_t*)(_retArea.ptr + (96+2*size_t.sizeof)) = cast(size_t)(_payload6615.levelSettings.customBiomeName.length); + *cast(void**)(_retArea.ptr + (96+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6615.levelSettings.customBiomeName.ptr)); + *cast(uint*)(_retArea.ptr + (96+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6615.levelSettings.dimension)); + *cast(uint*)(_retArea.ptr + (100+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6615.levelSettings.generatorType)); + *cast(ubyte*)(_retArea.ptr + (104+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.worldGamemode)); + *cast(ubyte*)(_retArea.ptr + (105+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.hardcore)); + *cast(uint*)(_retArea.ptr + (108+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6615.levelSettings.difficulty)); + *cast(uint*)(_retArea.ptr + (112+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6615.levelSettings.spawnPosition[0])); + *cast(uint*)(_retArea.ptr + (116+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6615.levelSettings.spawnPosition[1])); + *cast(uint*)(_retArea.ptr + (120+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6615.levelSettings.spawnPosition[2])); + *cast(ubyte*)(_retArea.ptr + (124+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.hasAchievementsDisabled)); + *cast(uint*)(_retArea.ptr + (128+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6615.levelSettings.editorWorldType)); + *cast(ubyte*)(_retArea.ptr + (132+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.isCreatedInEditor)); + *cast(ubyte*)(_retArea.ptr + (133+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.isExportedFromEditor)); + *cast(uint*)(_retArea.ptr + (136+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6615.levelSettings.dayCycleStopTime)); + *cast(uint*)(_retArea.ptr + (140+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6615.levelSettings.educationEditionOffer)); + *cast(ubyte*)(_retArea.ptr + (144+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.hasEducationFeaturesEnabled)); + *cast(size_t*)(_retArea.ptr + (144+5*size_t.sizeof)) = cast(size_t)(_payload6615.levelSettings.educationProductId.length); + *cast(void**)(_retArea.ptr + (144+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6615.levelSettings.educationProductId.ptr)); + *cast(float*)(_retArea.ptr + (144+6*size_t.sizeof)) = cast(float)(_payload6615.levelSettings.rainLevel); + *cast(float*)(_retArea.ptr + (148+6*size_t.sizeof)) = cast(float)(_payload6615.levelSettings.lightningLevel); + *cast(ubyte*)(_retArea.ptr + (152+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.hasConfirmedPlatformLockedContent)); + *cast(ubyte*)(_retArea.ptr + (153+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.wasMultiplayerIntended)); + *cast(ubyte*)(_retArea.ptr + (154+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.wasLanBroadcastingIntended)); + *cast(ubyte*)(_retArea.ptr + (155+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.xboxLiveBroadcastSetting)); + *cast(ubyte*)(_retArea.ptr + (156+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.platformBroadcastSetting)); + *cast(ubyte*)(_retArea.ptr + (157+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.commandsEnabled)); + *cast(ubyte*)(_retArea.ptr + (158+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.isTexturePacksRequired)); + auto _listSrc6617 = _payload6615.levelSettings.ruleData; + auto _list6617 = _listSrc6617.length ? wit.common.malloc(_listSrc6617.length * ((3*size_t.sizeof))) : null; + assert(!_listSrc6617.length || _list6617); + foreach (_elem6616_idx, ref _elem6616; _listSrc6617) { + auto _base6616 = _list6617 + _elem6616_idx * ((3*size_t.sizeof)); + *cast(size_t*)(_base6616 + size_t.sizeof) = cast(size_t)(_elem6616.ruleName.length); + *cast(void**)(_base6616 + 0) = cast(void*)(cast(void*)(_elem6616.ruleName.ptr)); + *cast(ubyte*)(_base6616 + (2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6616.ruleCanBeModified)); + *cast(ubyte*)(_base6616 + (1+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6616.ruleValue)); + + } + if (_listSrc6617.length) wit.common.free(_listSrc6617.ptr); + *cast(size_t*)(_retArea.ptr + (160+7*size_t.sizeof)) = cast(size_t)(_payload6615.levelSettings.ruleData.length); + *cast(void**)(_retArea.ptr + (160+6*size_t.sizeof)) = cast(void*)(_list6617); + auto _listSrc6619 = _payload6615.levelSettings.experiments.toggles; + auto _list6619 = _listSrc6619.length ? wit.common.malloc(_listSrc6619.length * ((3*size_t.sizeof))) : null; + assert(!_listSrc6619.length || _list6619); + foreach (_elem6618_idx, ref _elem6618; _listSrc6619) { + auto _base6618 = _list6619 + _elem6618_idx * ((3*size_t.sizeof)); + *cast(size_t*)(_base6618 + size_t.sizeof) = cast(size_t)(_elem6618.name.length); + *cast(void**)(_base6618 + 0) = cast(void*)(cast(void*)(_elem6618.name.ptr)); + *cast(ubyte*)(_base6618 + (2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6618.enabled)); + + } + if (_listSrc6619.length) wit.common.free(_listSrc6619.ptr); + *cast(size_t*)(_retArea.ptr + (160+9*size_t.sizeof)) = cast(size_t)(_payload6615.levelSettings.experiments.toggles.length); + *cast(void**)(_retArea.ptr + (160+8*size_t.sizeof)) = cast(void*)(_list6619); + *cast(ubyte*)(_retArea.ptr + (160+10*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.experiments.experimentsEverToggled)); + *cast(ubyte*)(_retArea.ptr + (160+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.bonusChest)); + *cast(ubyte*)(_retArea.ptr + (161+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.hasStartWithMapEnabled)); + *cast(ubyte*)(_retArea.ptr + (162+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.permissionLevel)); + *cast(uint*)(_retArea.ptr + (164+11*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6615.levelSettings.serverSimulationDistance)); + *cast(ubyte*)(_retArea.ptr + (168+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.hasLockedBehaviorPack)); + *cast(ubyte*)(_retArea.ptr + (169+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.hasLockedResourcePack)); + *cast(ubyte*)(_retArea.ptr + (170+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.isFromLockedWorldTemplate)); + *cast(ubyte*)(_retArea.ptr + (171+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.isUsingMsaGamertagsOnly)); + *cast(ubyte*)(_retArea.ptr + (172+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.isFromWorldTemplate)); + *cast(ubyte*)(_retArea.ptr + (173+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.isWorldTemplateOptionLocked)); + *cast(ubyte*)(_retArea.ptr + (174+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.isOnlySpawningV1Villagers)); + *cast(ubyte*)(_retArea.ptr + (175+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.isDisablingPersonas)); + *cast(ubyte*)(_retArea.ptr + (176+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.isDisablingCustomSkins)); + *cast(ubyte*)(_retArea.ptr + (177+11*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.emoteChatMuted)); + *cast(size_t*)(_retArea.ptr + (176+13*size_t.sizeof)) = cast(size_t)(_payload6615.levelSettings.gameVersion.length); + *cast(void**)(_retArea.ptr + (176+12*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6615.levelSettings.gameVersion.ptr)); + *cast(uint*)(_retArea.ptr + (176+14*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6615.levelSettings.limitedWorldWidth)); + *cast(uint*)(_retArea.ptr + (180+14*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6615.levelSettings.limitedWorldHeight)); + *cast(ubyte*)(_retArea.ptr + (184+14*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.newNether)); + *cast(size_t*)(_retArea.ptr + (184+16*size_t.sizeof)) = cast(size_t)(_payload6615.levelSettings.eduSharedUriButtonName.length); + *cast(void**)(_retArea.ptr + (184+15*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6615.levelSettings.eduSharedUriButtonName.ptr)); + *cast(size_t*)(_retArea.ptr + (184+18*size_t.sizeof)) = cast(size_t)(_payload6615.levelSettings.eduSharedUriLinkUri.length); + *cast(void**)(_retArea.ptr + (184+17*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6615.levelSettings.eduSharedUriLinkUri.ptr)); + *cast(ubyte*)(_retArea.ptr + (184+19*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.overrideForceExperimentalGameplayHasValue)); + *cast(ubyte*)(_retArea.ptr + (185+19*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.chatRestrictionLevel)); + *cast(ubyte*)(_retArea.ptr + (186+19*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.disablePlayerInteractions)); + *cast(uint*)(_retArea.ptr + (188+19*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6615.levelSettings.serverEditorConnectionPolicy)); + *cast(ubyte*)(_retArea.ptr + (192+19*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.levelSettings.allowAnonymousBlockDropsInEditorWorlds)); + *cast(size_t*)(_retArea.ptr + (192+21*size_t.sizeof)) = cast(size_t)(_payload6615.levelId.length); + *cast(void**)(_retArea.ptr + (192+20*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6615.levelId.ptr)); + *cast(size_t*)(_retArea.ptr + (192+23*size_t.sizeof)) = cast(size_t)(_payload6615.levelName.length); + *cast(void**)(_retArea.ptr + (192+22*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6615.levelName.ptr)); + *cast(size_t*)(_retArea.ptr + (192+25*size_t.sizeof)) = cast(size_t)(_payload6615.premiumWorldTemplateId.length); + *cast(void**)(_retArea.ptr + (192+24*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6615.premiumWorldTemplateId.ptr)); + *cast(ubyte*)(_retArea.ptr + (192+26*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.isTrial)); + *cast(uint*)(_retArea.ptr + (196+26*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6615.rewindHistorySize)); + *cast(ubyte*)(_retArea.ptr + (200+26*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.serverAuthoritativeBlockBreaking)); + *cast(ulong*)(_retArea.ptr + (208+26*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload6615.currentLevelTime)); + *cast(uint*)(_retArea.ptr + (216+26*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6615.enchantmentSeed)); + *cast(uint*)(_retArea.ptr + (220+26*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6615.blockPropertiesSize)); + *cast(size_t*)(_retArea.ptr + (224+27*size_t.sizeof)) = cast(size_t)(_payload6615.multiplayerCorrelationId.length); + *cast(void**)(_retArea.ptr + (224+26*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6615.multiplayerCorrelationId.ptr)); + *cast(ubyte*)(_retArea.ptr + (224+28*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.enableItemstackNetManager)); + *cast(size_t*)(_retArea.ptr + (224+30*size_t.sizeof)) = cast(size_t)(_payload6615.serverVersion.length); + *cast(void**)(_retArea.ptr + (224+29*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6615.serverVersion.ptr)); + *cast(ubyte*)(_retArea.ptr + (224+31*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.compoundId)); + *cast(uint*)(_retArea.ptr + (228+31*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6615.compoundLen)); + *cast(ubyte*)(_retArea.ptr + (232+31*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.compoundEnd)); + *cast(ulong*)(_retArea.ptr + (232+32*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload6615.blockRegistryChecksum)); + *cast(ulong*)(_retArea.ptr + (240+32*size_t.sizeof)) = cast(ulong)(_payload6615.worldTemplateId.high); + *cast(ulong*)(_retArea.ptr + (248+32*size_t.sizeof)) = cast(ulong)(_payload6615.worldTemplateId.low); + *cast(ubyte*)(_retArea.ptr + (256+32*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.enableClientsideGeneration)); + *cast(ubyte*)(_retArea.ptr + (257+32*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.blocknetworkIdsAreHashed)); + *cast(ubyte*)(_retArea.ptr + (258+32*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6615.serverAuthSounds)); + if (_payload6615.serverJoinInformation.isSome) { + ref _payload6623 = _payload6615.serverJoinInformation.unwrap(); + *cast(ubyte*)(_retArea.ptr + (264+32*size_t.sizeof)) = cast(ubyte)(1); + if (_payload6623.gathering.isSome) { + ref _payload6627 = _payload6623.gathering.unwrap(); + *cast(ubyte*)(_retArea.ptr + (272+32*size_t.sizeof)) = cast(ubyte)(1); + *cast(ulong*)(_retArea.ptr + (280+32*size_t.sizeof)) = cast(ulong)(_payload6627.experienceId.high); + *cast(ulong*)(_retArea.ptr + (288+32*size_t.sizeof)) = cast(ulong)(_payload6627.experienceId.low); + *cast(size_t*)(_retArea.ptr + (296+33*size_t.sizeof)) = cast(size_t)(_payload6627.experienceName.length); + *cast(void**)(_retArea.ptr + (296+32*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6627.experienceName.ptr)); + *cast(ulong*)(_retArea.ptr + (296+34*size_t.sizeof)) = cast(ulong)(_payload6627.experienceWorldId.high); + *cast(ulong*)(_retArea.ptr + (304+34*size_t.sizeof)) = cast(ulong)(_payload6627.experienceWorldId.low); + *cast(size_t*)(_retArea.ptr + (312+35*size_t.sizeof)) = cast(size_t)(_payload6627.experienceWorldName.length); + *cast(void**)(_retArea.ptr + (312+34*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6627.experienceWorldName.ptr)); + *cast(size_t*)(_retArea.ptr + (312+37*size_t.sizeof)) = cast(size_t)(_payload6627.creatorId.length); + *cast(void**)(_retArea.ptr + (312+36*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6627.creatorId.ptr)); + *cast(ulong*)(_retArea.ptr + (312+38*size_t.sizeof)) = cast(ulong)(_payload6627.unknownUuid1.high); + *cast(ulong*)(_retArea.ptr + (320+38*size_t.sizeof)) = cast(ulong)(_payload6627.unknownUuid1.low); + *cast(ulong*)(_retArea.ptr + (328+38*size_t.sizeof)) = cast(ulong)(_payload6627.unknownUuid2.high); + *cast(ulong*)(_retArea.ptr + (336+38*size_t.sizeof)) = cast(ulong)(_payload6627.unknownUuid2.low); + *cast(size_t*)(_retArea.ptr + (344+39*size_t.sizeof)) = cast(size_t)(_payload6627.serverId.length); + *cast(void**)(_retArea.ptr + (344+38*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6627.serverId.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (272+32*size_t.sizeof)) = cast(ubyte)(0); + } + if (_payload6623.storeEntryPoint.isSome) { + ref _payload6631 = _payload6623.storeEntryPoint.unwrap(); + *cast(ubyte*)(_retArea.ptr + (344+40*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (344+42*size_t.sizeof)) = cast(size_t)(_payload6631.storeId.length); + *cast(void**)(_retArea.ptr + (344+41*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6631.storeId.ptr)); + *cast(size_t*)(_retArea.ptr + (344+44*size_t.sizeof)) = cast(size_t)(_payload6631.storeName.length); + *cast(void**)(_retArea.ptr + (344+43*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6631.storeName.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (344+40*size_t.sizeof)) = cast(ubyte)(0); + } + if (_payload6623.presence.isSome) { + ref _payload6635 = _payload6623.presence.unwrap(); + *cast(ubyte*)(_retArea.ptr + (344+45*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (344+47*size_t.sizeof)) = cast(size_t)(_payload6635.experienceName.length); + *cast(void**)(_retArea.ptr + (344+46*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6635.experienceName.ptr)); + *cast(size_t*)(_retArea.ptr + (344+49*size_t.sizeof)) = cast(size_t)(_payload6635.worldName.length); + *cast(void**)(_retArea.ptr + (344+48*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6635.worldName.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (344+45*size_t.sizeof)) = cast(ubyte)(0); + } + } else { + *cast(ubyte*)(_retArea.ptr + (264+32*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(size_t*)(_retArea.ptr + (344+51*size_t.sizeof)) = cast(size_t)(_payload6615.telemetry.serverId.length); + *cast(void**)(_retArea.ptr + (344+50*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6615.telemetry.serverId.ptr)); + *cast(size_t*)(_retArea.ptr + (344+53*size_t.sizeof)) = cast(size_t)(_payload6615.telemetry.scenarioId.length); + *cast(void**)(_retArea.ptr + (344+52*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6615.telemetry.scenarioId.ptr)); + *cast(size_t*)(_retArea.ptr + (344+55*size_t.sizeof)) = cast(size_t)(_payload6615.telemetry.worldId.length); + *cast(void**)(_retArea.ptr + (344+54*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6615.telemetry.worldId.ptr)); + *cast(size_t*)(_retArea.ptr + (344+57*size_t.sizeof)) = cast(size_t)(_payload6615.telemetry.ownerId.length); + *cast(void**)(_retArea.ptr + (344+56*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6615.telemetry.ownerId.ptr)); + break; + } + case _Tag6654.cTakeItemActor: { + ref wit.pumpkin.plugin.bedrock_packets.common.CTakeItemActor _payload6637 = _payload6352.getCTakeItemActor(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(52); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload6637.itemRuntimeId)); + *cast(ulong*)(_retArea.ptr + 40) = cast(ulong)(cast(ulong)(_payload6637.actorRuntimeId)); + break; + } + case _Tag6654.cTransfer: { + ref wit.pumpkin.plugin.bedrock_packets.common.CTransfer _payload6639 = _payload6352.getCTransfer(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(53); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6639.serverAddress.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6639.serverAddress.ptr)); + *cast(uint*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6639.serverPort)); + *cast(ubyte*)(_retArea.ptr + (36+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6639.reloadWorld)); + break; + } + case _Tag6654.cUpdateAbilities: { + ref wit.pumpkin.plugin.bedrock_packets.common.CUpdateAbilities _payload6641 = _payload6352.getCUpdateAbilities(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(54); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload6641.data.targetPlayerRawId)); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(cast(uint)(_payload6641.data.playerPermissions)); + *cast(ubyte*)(_retArea.ptr + 41) = cast(ubyte)(cast(uint)(_payload6641.data.commandPermissions)); + *cast(size_t*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(size_t)(_payload6641.data.layers.length); + *cast(void**)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6641.data.layers.ptr)); + break; + } + case _Tag6654.cUpdateAttributes: { + ref wit.pumpkin.plugin.bedrock_packets.common.CUpdateAttributes _payload6643 = _payload6352.getCUpdateAttributes(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(55); + *cast(ulong*)(_retArea.ptr + 32) = cast(ulong)(cast(ulong)(_payload6643.targetRuntimeId)); + auto _listSrc6647 = _payload6643.attributeList; + auto _list6647 = _listSrc6647.length ? wit.common.malloc(_listSrc6647.length * ((24+4*size_t.sizeof))) : null; + assert(!_listSrc6647.length || _list6647); + foreach (_elem6644_idx, ref _elem6644; _listSrc6647) { + auto _base6644 = _list6647 + _elem6644_idx * ((24+4*size_t.sizeof)); + *cast(float*)(_base6644 + 0) = cast(float)(_elem6644.minValue); + *cast(float*)(_base6644 + 4) = cast(float)(_elem6644.maxValue); + *cast(float*)(_base6644 + 8) = cast(float)(_elem6644.currentValue); + *cast(float*)(_base6644 + 12) = cast(float)(_elem6644.defaultMinValue); + *cast(float*)(_base6644 + 16) = cast(float)(_elem6644.defaultMaxValue); + *cast(float*)(_base6644 + 20) = cast(float)(_elem6644.defaultValue); + *cast(size_t*)(_base6644 + (24+1*size_t.sizeof)) = cast(size_t)(_elem6644.name.length); + *cast(void**)(_base6644 + 24) = cast(void*)(cast(void*)(_elem6644.name.ptr)); + auto _listSrc6646 = _elem6644.modifiers; + auto _list6646 = _listSrc6646.length ? wit.common.malloc(_listSrc6646.length * ((16+4*size_t.sizeof))) : null; + assert(!_listSrc6646.length || _list6646); + foreach (_elem6645_idx, ref _elem6645; _listSrc6646) { + auto _base6645 = _list6646 + _elem6645_idx * ((16+4*size_t.sizeof)); + *cast(size_t*)(_base6645 + size_t.sizeof) = cast(size_t)(_elem6645.id.length); + *cast(void**)(_base6645 + 0) = cast(void*)(cast(void*)(_elem6645.id.ptr)); + *cast(size_t*)(_base6645 + (3*size_t.sizeof)) = cast(size_t)(_elem6645.name.length); + *cast(void**)(_base6645 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem6645.name.ptr)); + *cast(float*)(_base6645 + (4*size_t.sizeof)) = cast(float)(_elem6645.amount); + *cast(uint*)(_base6645 + (4+4*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6645.operation)); + *cast(uint*)(_base6645 + (8+4*size_t.sizeof)) = cast(uint)(cast(uint)(_elem6645.operand)); + *cast(ubyte*)(_base6645 + (12+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_elem6645.isSerializable)); + + } + if (_listSrc6646.length) wit.common.free(_listSrc6646.ptr); + *cast(size_t*)(_base6644 + (24+3*size_t.sizeof)) = cast(size_t)(_elem6644.modifiers.length); + *cast(void**)(_base6644 + (24+2*size_t.sizeof)) = cast(void*)(_list6646); + + } + if (_listSrc6647.length) wit.common.free(_listSrc6647.ptr); + *cast(size_t*)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(size_t)(_payload6643.attributeList.length); + *cast(void**)(_retArea.ptr + 40) = cast(void*)(_list6647); + *cast(ulong*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(ulong)(cast(ulong)(_payload6643.tick)); + break; + } + case _Tag6654.cUpdateBlock: { + ref wit.pumpkin.plugin.bedrock_packets.common.CUpdateBlock _payload6649 = _payload6352.getCUpdateBlock(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(56); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6649.blockPosition[0])); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6649.blockPosition[1])); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload6649.blockPosition[2])); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload6649.blockRuntimeId)); + *cast(uint*)(_retArea.ptr + 48) = cast(uint)(cast(uint)(_payload6649.flags)); + *cast(uint*)(_retArea.ptr + 52) = cast(uint)(cast(uint)(_payload6649.layer)); + break; + } + case _Tag6654.cUpdateTrade: { + ref wit.pumpkin.plugin.bedrock_packets.common.CUpdateTrade _payload6651 = _payload6352.getCUpdateTrade(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(57); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6651.containerId)); + *cast(ubyte*)(_retArea.ptr + 33) = cast(ubyte)(cast(uint)(_payload6651.rType)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload6651.size)); + *cast(uint*)(_retArea.ptr + 40) = cast(uint)(cast(uint)(_payload6651.traderTier)); + *cast(ulong*)(_retArea.ptr + 48) = cast(ulong)(cast(ulong)(_payload6651.entityUniqueId)); + *cast(ulong*)(_retArea.ptr + 56) = cast(ulong)(cast(ulong)(_payload6651.lastTradingPlayer)); + *cast(size_t*)(_retArea.ptr + (64+1*size_t.sizeof)) = cast(size_t)(_payload6651.displayName.length); + *cast(void**)(_retArea.ptr + 64) = cast(void*)(cast(void*)(_payload6651.displayName.ptr)); + *cast(ubyte*)(_retArea.ptr + (64+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6651.useNewTradeScreen)); + *cast(ubyte*)(_retArea.ptr + (65+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6651.usingEconomyTrade)); + *cast(size_t*)(_retArea.ptr + (64+4*size_t.sizeof)) = cast(size_t)(_payload6651.data.length); + *cast(void**)(_retArea.ptr + (64+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6651.data.ptr)); + break; + } + case _Tag6654.unknown: { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(58); + break; + } + } + break; + } + case _Tag6657.unknown: { + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(2); + break; + } + } + *cast(uint*)(_retArea.ptr + (344+58*size_t.sizeof)) = cast(uint)(cast(uint)(_payload5595.packetId)); + *cast(size_t*)(_retArea.ptr + (344+60*size_t.sizeof)) = cast(size_t)(_payload5595.rawPayload.length); + *cast(void**)(_retArea.ptr + (344+59*size_t.sizeof)) = cast(void*)(cast(void*)(_payload5595.rawPayload.ptr)); + *cast(ubyte*)(_retArea.ptr + (344+61*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload5595.cancelled)); + break; + } + case _Tag7236.chunkLoadEvent: { + ref wit.pumpkin.plugin.event.imports.ChunkLoadEventData _payload6659 = _ret.getChunkLoadEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(44); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6659.targetWorld.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6659.chunkX)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6659.chunkZ)); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload6659.cancelled)); + break; + } + case _Tag7236.chunkSaveEvent: { + ref wit.pumpkin.plugin.event.imports.ChunkSaveEventData _payload6661 = _ret.getChunkSaveEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(45); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6661.targetWorld.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6661.chunkX)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6661.chunkZ)); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload6661.cancelled)); + break; + } + case _Tag7236.chunkSendEvent: { + ref wit.pumpkin.plugin.event.imports.ChunkSendEventData _payload6663 = _ret.getChunkSendEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(46); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6663.targetWorld.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6663.chunkX)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6663.chunkZ)); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload6663.cancelled)); + break; + } + case _Tag7236.entityDamageEvent: { + ref wit.pumpkin.plugin.event.common.EntityDamageEventData _payload6665 = _ret.getEntityDamageEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(47); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6665.entityId)); + *cast(float*)(_retArea.ptr + 12) = cast(float)(_payload6665.damage); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload6665.damageType)); + *cast(ubyte*)(_retArea.ptr + 17) = cast(ubyte)(cast(uint)(_payload6665.cancelled)); + break; + } + case _Tag7236.entityDeathEvent: { + ref wit.pumpkin.plugin.event.common.EntityDeathEventData _payload6667 = _ret.getEntityDeathEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(48); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6667.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6667.droppedExp)); + break; + } + case _Tag7236.playerDeathEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerDeathEventData _payload6669 = _ret.getPlayerDeathEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(49); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6669.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(_payload6669.deathMessage.__handle); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6669.droppedExp)); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload6669.keepInventory)); + *cast(ubyte*)(_retArea.ptr + 21) = cast(ubyte)(cast(uint)(_payload6669.cancelled)); + break; + } + case _Tag7236.entitySpawnEvent: { + ref wit.pumpkin.plugin.event.imports.EntitySpawnEventData _payload6671 = _ret.getEntitySpawnEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(50); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6671.entityId)); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload6671.entityType.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6671.entityType.ptr)); + *cast(double*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(double)(_payload6671.position[0]); + *cast(double*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(double)(_payload6671.position[1]); + *cast(double*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(double)(_payload6671.position[2]); + *cast(uint*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(uint)(_payload6671.targetWorld.__handle); + *cast(ubyte*)(_retArea.ptr + (44+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6671.cancelled)); + break; + } + case _Tag7236.entityCombustEvent: { + ref wit.pumpkin.plugin.event.common.EntityCombustEventData _payload6673 = _ret.getEntityCombustEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(51); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6673.entityId)); + *cast(float*)(_retArea.ptr + 12) = cast(float)(_payload6673.durationSecs); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload6673.cancelled)); + break; + } + case _Tag7236.entityRegainHealthEvent: { + ref wit.pumpkin.plugin.event.common.EntityRegainHealthEventData _payload6675 = _ret.getEntityRegainHealthEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(52); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6675.entityId)); + *cast(float*)(_retArea.ptr + 12) = cast(float)(_payload6675.amount); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload6675.cancelled)); + break; + } + case _Tag7236.entityAirChangeEvent: { + ref wit.pumpkin.plugin.event.common.EntityAirChangeEventData _payload6677 = _ret.getEntityAirChangeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(53); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6677.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6677.amount)); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload6677.cancelled)); + break; + } + case _Tag7236.entityBreedEvent: { + ref wit.pumpkin.plugin.event.common.EntityBreedEventData _payload6679 = _ret.getEntityBreedEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(54); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6679.fatherId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6679.motherId)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6679.childId)); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload6679.cancelled)); + break; + } + case _Tag7236.entityDismountEvent: { + ref wit.pumpkin.plugin.event.common.EntityDismountEventData _payload6681 = _ret.getEntityDismountEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(55); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6681.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6681.dismountedId)); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload6681.cancelled)); + break; + } + case _Tag7236.entityDyeEvent: { + ref wit.pumpkin.plugin.event.imports.EntityDyeEventData _payload6683 = _ret.getEntityDyeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(56); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6683.entityId)); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload6683.color.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6683.color.ptr)); + if (_payload6683.player.isSome) { + ref _payload6687 = _payload6683.player.unwrap(); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (12+3*size_t.sizeof)) = cast(uint)(_payload6687.__handle); + } else { + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6683.cancelled)); + break; + } + case _Tag7236.entityEnterLoveModeEvent: { + ref wit.pumpkin.plugin.event.common.EntityEnterLoveModeEventData _payload6689 = _ret.getEntityEnterLoveModeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(57); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6689.entityId)); + if (_payload6689.humanEntityId.isSome) { + ref _payload6693 = _payload6689.humanEntityId.unwrap(); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6693)); + } else { + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(0); + } + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6689.ticksInLove)); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload6689.cancelled)); + break; + } + case _Tag7236.entityExplodeEvent: { + ref wit.pumpkin.plugin.event.common.EntityExplodeEventData _payload6695 = _ret.getEntityExplodeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(58); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6695.entityId)); + *cast(double*)(_retArea.ptr + 16) = cast(double)(_payload6695.position[0]); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload6695.position[1]); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload6695.position[2]); + *cast(float*)(_retArea.ptr + 40) = cast(float)(_payload6695.yieldRate); + *cast(ubyte*)(_retArea.ptr + 44) = cast(ubyte)(cast(uint)(_payload6695.cancelled)); + break; + } + case _Tag7236.entityMountEvent: { + ref wit.pumpkin.plugin.event.common.EntityMountEventData _payload6697 = _ret.getEntityMountEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(59); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6697.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6697.mountedId)); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload6697.cancelled)); + break; + } + case _Tag7236.entityPickupItemEvent: { + ref wit.pumpkin.plugin.event.common.EntityPickupItemEventData _payload6699 = _ret.getEntityPickupItemEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(60); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6699.entityId)); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload6699.itemName.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6699.itemName.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6699.count)); + *cast(ubyte*)(_retArea.ptr + (9+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6699.cancelled)); + break; + } + case _Tag7236.entityPortalEvent: { + ref wit.pumpkin.plugin.event.common.EntityPortalEventData _payload6701 = _ret.getEntityPortalEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(61); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6701.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6701.portalPos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6701.portalPos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6701.portalPos.z)); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload6701.cancelled)); + break; + } + case _Tag7236.entityResurrectEvent: { + ref wit.pumpkin.plugin.event.common.EntityResurrectEventData _payload6703 = _ret.getEntityResurrectEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(62); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6703.entityId)); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload6703.cancelled)); + break; + } + case _Tag7236.entityShootBowEvent: { + ref wit.pumpkin.plugin.event.common.EntityShootBowEventData _payload6705 = _ret.getEntityShootBowEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(63); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6705.entityId)); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload6705.weaponName.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6705.weaponName.ptr)); + *cast(float*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(float)(_payload6705.force); + *cast(ubyte*)(_retArea.ptr + (12+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6705.cancelled)); + break; + } + case _Tag7236.entityTameEvent: { + ref wit.pumpkin.plugin.event.imports.EntityTameEventData _payload6707 = _ret.getEntityTameEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(64); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6707.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(_payload6707.owner.__handle); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload6707.cancelled)); + break; + } + case _Tag7236.entityTargetEvent: { + ref wit.pumpkin.plugin.event.common.EntityTargetEventData _payload6709 = _ret.getEntityTargetEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(65); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6709.entityId)); + if (_payload6709.targetId.isSome) { + ref _payload6713 = _payload6709.targetId.unwrap(); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6713)); + } else { + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload6709.cancelled)); + break; + } + case _Tag7236.entityTeleportEvent: { + ref wit.pumpkin.plugin.event.common.EntityTeleportEventData _payload6715 = _ret.getEntityTeleportEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(66); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6715.entityId)); + *cast(double*)(_retArea.ptr + 16) = cast(double)(_payload6715.fromPosition[0]); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload6715.fromPosition[1]); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload6715.fromPosition[2]); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload6715.toPosition[0]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload6715.toPosition[1]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload6715.toPosition[2]); + *cast(ubyte*)(_retArea.ptr + 64) = cast(ubyte)(cast(uint)(_payload6715.cancelled)); + break; + } + case _Tag7236.entityToggleGlideEvent: { + ref wit.pumpkin.plugin.event.common.EntityToggleGlideEventData _payload6717 = _ret.getEntityToggleGlideEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(67); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6717.entityId)); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload6717.isGliding)); + *cast(ubyte*)(_retArea.ptr + 13) = cast(ubyte)(cast(uint)(_payload6717.cancelled)); + break; + } + case _Tag7236.entityTransformEvent: { + ref wit.pumpkin.plugin.event.common.EntityTransformEventData _payload6719 = _ret.getEntityTransformEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(68); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6719.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6719.newEntityId)); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload6719.transformReason.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload6719.transformReason.ptr)); + *cast(ubyte*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6719.cancelled)); + break; + } + case _Tag7236.playerItemConsumeEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerItemConsumeEventData _payload6721 = _ret.getPlayerItemConsumeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(69); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6721.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload6721.itemName.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6721.itemName.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6721.cancelled)); + break; + } + case _Tag7236.playerItemDamageEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerItemDamageEventData _payload6723 = _ret.getPlayerItemDamageEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(70); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6723.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload6723.itemName.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6723.itemName.ptr)); + *cast(uint*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6723.damage)); + *cast(ubyte*)(_retArea.ptr + (12+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6723.cancelled)); + break; + } + case _Tag7236.playerDropItemEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerDropItemEventData _payload6725 = _ret.getPlayerDropItemEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(71); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6725.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload6725.itemName.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6725.itemName.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6725.count)); + *cast(ubyte*)(_retArea.ptr + (9+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6725.cancelled)); + break; + } + case _Tag7236.playerBedEnterEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerBedEnterEventData _payload6727 = _ret.getPlayerBedEnterEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(72); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6727.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6727.bedPos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6727.bedPos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6727.bedPos.z)); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload6727.cancelled)); + break; + } + case _Tag7236.playerBedLeaveEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerBedLeaveEventData _payload6729 = _ret.getPlayerBedLeaveEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(73); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6729.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6729.bedPos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6729.bedPos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6729.bedPos.z)); + break; + } + case _Tag7236.playerBucketEmptyEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerBucketEmptyEventData _payload6731 = _ret.getPlayerBucketEmptyEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(74); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6731.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6731.blockPos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6731.blockPos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6731.blockPos.z)); + *cast(size_t*)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(size_t)(_payload6731.bucket.length); + *cast(void**)(_retArea.ptr + 24) = cast(void*)(cast(void*)(_payload6731.bucket.ptr)); + *cast(ubyte*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6731.cancelled)); + break; + } + case _Tag7236.playerBucketFillEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerBucketFillEventData _payload6733 = _ret.getPlayerBucketFillEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(75); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6733.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6733.blockPos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6733.blockPos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6733.blockPos.z)); + *cast(size_t*)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(size_t)(_payload6733.bucket.length); + *cast(void**)(_retArea.ptr + 24) = cast(void*)(cast(void*)(_payload6733.bucket.ptr)); + *cast(ubyte*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6733.cancelled)); + break; + } + case _Tag7236.blockDamageEvent: { + ref wit.pumpkin.plugin.event.imports.BlockDamageEventData _payload6735 = _ret.getBlockDamageEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(76); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6735.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6735.blockPos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6735.blockPos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6735.blockPos.z)); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload6735.instaBreak)); + *cast(ubyte*)(_retArea.ptr + 25) = cast(ubyte)(cast(uint)(_payload6735.cancelled)); + break; + } + case _Tag7236.blockIgniteEvent: { + ref wit.pumpkin.plugin.event.common.BlockIgniteEventData _payload6737 = _ret.getBlockIgniteEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(77); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6737.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6737.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6737.blockPos.z)); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload6737.cancelled)); + break; + } + case _Tag7236.blockFromToEvent: { + ref wit.pumpkin.plugin.event.common.BlockFromToEventData _payload6739 = _ret.getBlockFromToEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(78); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6739.fromPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6739.fromPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6739.fromPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6739.toPos.x)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload6739.toPos.y)); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload6739.toPos.z)); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6739.cancelled)); + break; + } + case _Tag7236.blockFormEvent: { + ref wit.pumpkin.plugin.event.common.BlockFormEventData _payload6741 = _ret.getBlockFormEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(79); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6741.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6741.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6741.blockPos.z)); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload6741.cancelled)); + break; + } + case _Tag7236.blockFadeEvent: { + ref wit.pumpkin.plugin.event.common.BlockFadeEventData _payload6743 = _ret.getBlockFadeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(80); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6743.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6743.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6743.blockPos.z)); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload6743.cancelled)); + break; + } + case _Tag7236.blockDispenseEvent: { + ref wit.pumpkin.plugin.event.common.BlockDispenseEventData _payload6745 = _ret.getBlockDispenseEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(81); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6745.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6745.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6745.blockPos.z)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload6745.itemName.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6745.itemName.ptr)); + *cast(ubyte*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6745.cancelled)); + break; + } + case _Tag7236.blockExplodeEvent: { + ref wit.pumpkin.plugin.event.common.BlockExplodeEventData _payload6747 = _ret.getBlockExplodeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(82); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6747.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6747.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6747.blockPos.z)); + *cast(float*)(_retArea.ptr + 20) = cast(float)(_payload6747.yieldRate); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload6747.cancelled)); + break; + } + case _Tag7236.blockPhysicsEvent: { + ref wit.pumpkin.plugin.event.common.BlockPhysicsEventData _payload6749 = _ret.getBlockPhysicsEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(83); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6749.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6749.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6749.blockPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6749.changedPos.x)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload6749.changedPos.y)); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload6749.changedPos.z)); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6749.cancelled)); + break; + } + case _Tag7236.blockPistonExtendEvent: { + ref wit.pumpkin.plugin.event.common.BlockPistonExtendEventData _payload6751 = _ret.getBlockPistonExtendEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(84); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6751.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6751.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6751.blockPos.z)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload6751.direction.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6751.direction.ptr)); + *cast(ubyte*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6751.cancelled)); + break; + } + case _Tag7236.blockPistonRetractEvent: { + ref wit.pumpkin.plugin.event.common.BlockPistonRetractEventData _payload6753 = _ret.getBlockPistonRetractEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(85); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6753.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6753.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6753.blockPos.z)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload6753.direction.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6753.direction.ptr)); + *cast(ubyte*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6753.cancelled)); + break; + } + case _Tag7236.notePlayEvent: { + ref wit.pumpkin.plugin.event.common.NotePlayEventData _payload6755 = _ret.getNotePlayEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(86); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6755.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6755.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6755.blockPos.z)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload6755.instrument.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6755.instrument.ptr)); + *cast(ubyte*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6755.note)); + *cast(ubyte*)(_retArea.ptr + (17+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6755.cancelled)); + break; + } + case _Tag7236.signChangeEvent: { + ref wit.pumpkin.plugin.event.imports.SignChangeEventData _payload6757 = _ret.getSignChangeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(87); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6757.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6757.blockPos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6757.blockPos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6757.blockPos.z)); + auto _listSrc6759 = _payload6757.lines; + auto _list6759 = _listSrc6759.length ? wit.common.malloc(_listSrc6759.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc6759.length || _list6759); + foreach (_elem6758_idx, ref _elem6758; _listSrc6759) { + auto _base6758 = _list6759 + _elem6758_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6758 + size_t.sizeof) = cast(size_t)(_elem6758.length); + *cast(void**)(_base6758 + 0) = cast(void*)(cast(void*)(_elem6758.ptr)); + + } + if (_listSrc6759.length) wit.common.free(_listSrc6759.ptr); + *cast(size_t*)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(size_t)(_payload6757.lines.length); + *cast(void**)(_retArea.ptr + 24) = cast(void*)(_list6759); + *cast(ubyte*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6757.cancelled)); + break; + } + case _Tag7236.spongeAbsorbEvent: { + ref wit.pumpkin.plugin.event.common.SpongeAbsorbEventData _payload6761 = _ret.getSpongeAbsorbEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(88); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6761.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6761.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6761.blockPos.z)); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload6761.cancelled)); + break; + } + case _Tag7236.tntPrimeEvent: { + ref wit.pumpkin.plugin.event.common.TntPrimeEventData _payload6763 = _ret.getTntPrimeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(89); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6763.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6763.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6763.blockPos.z)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload6763.primeReason.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6763.primeReason.ptr)); + *cast(ubyte*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6763.cancelled)); + break; + } + case _Tag7236.weatherChangeEvent: { + ref wit.pumpkin.plugin.event.imports.WeatherChangeEventData _payload6765 = _ret.getWeatherChangeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(90); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6765.targetWorld.__handle); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload6765.toWeatherState)); + *cast(ubyte*)(_retArea.ptr + 13) = cast(ubyte)(cast(uint)(_payload6765.cancelled)); + break; + } + case _Tag7236.thunderChangeEvent: { + ref wit.pumpkin.plugin.event.imports.ThunderChangeEventData _payload6767 = _ret.getThunderChangeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(91); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6767.targetWorld.__handle); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload6767.toThunderState)); + *cast(ubyte*)(_retArea.ptr + 13) = cast(ubyte)(cast(uint)(_payload6767.cancelled)); + break; + } + case _Tag7236.worldLoadEvent: { + ref wit.pumpkin.plugin.event.imports.WorldLoadEventData _payload6769 = _ret.getWorldLoadEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(92); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6769.targetWorld.__handle); + break; + } + case _Tag7236.worldUnloadEvent: { + ref wit.pumpkin.plugin.event.imports.WorldUnloadEventData _payload6771 = _ret.getWorldUnloadEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(93); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6771.targetWorld.__handle); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload6771.cancelled)); + break; + } + case _Tag7236.asyncStructureGenerateEvent: { + ref wit.pumpkin.plugin.event.common.AsyncStructureGenerateEventData _payload6773 = _ret.getAsyncStructureGenerateEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(94); + *cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(size_t)(_payload6773.worldName.length); + *cast(void**)(_retArea.ptr + 8) = cast(void*)(cast(void*)(_payload6773.worldName.ptr)); + *cast(size_t*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(size_t)(_payload6773.structureName.length); + *cast(void**)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6773.structureName.ptr)); + *cast(uint*)(_retArea.ptr + (8+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6773.pos.x)); + *cast(uint*)(_retArea.ptr + (12+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6773.pos.y)); + *cast(uint*)(_retArea.ptr + (16+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6773.pos.z)); + *cast(ubyte*)(_retArea.ptr + (20+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6773.cancelled)); + break; + } + case _Tag7236.asyncStructureSpawnEvent: { + ref wit.pumpkin.plugin.event.common.AsyncStructureSpawnEventData _payload6775 = _ret.getAsyncStructureSpawnEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(95); + *cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(size_t)(_payload6775.worldName.length); + *cast(void**)(_retArea.ptr + 8) = cast(void*)(cast(void*)(_payload6775.worldName.ptr)); + *cast(size_t*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(size_t)(_payload6775.structureName.length); + *cast(void**)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6775.structureName.ptr)); + *cast(uint*)(_retArea.ptr + (8+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6775.pos.x)); + *cast(uint*)(_retArea.ptr + (12+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6775.pos.y)); + *cast(uint*)(_retArea.ptr + (16+4*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6775.pos.z)); + *cast(ubyte*)(_retArea.ptr + (20+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6775.cancelled)); + break; + } + case _Tag7236.chunkPopulateEvent: { + ref wit.pumpkin.plugin.event.common.ChunkPopulateEventData _payload6777 = _ret.getChunkPopulateEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(96); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6777.chunkX)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6777.chunkZ)); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload6777.cancelled)); + break; + } + case _Tag7236.chunkUnloadEvent: { + ref wit.pumpkin.plugin.event.common.ChunkUnloadEventData _payload6779 = _ret.getChunkUnloadEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(97); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6779.chunkX)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6779.chunkZ)); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload6779.cancelled)); + break; + } + case _Tag7236.entitiesLoadEvent: { + ref wit.pumpkin.plugin.event.common.EntitiesLoadEventData _payload6781 = _ret.getEntitiesLoadEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(98); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6781.chunkX)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6781.chunkZ)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(_payload6781.entityCount); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload6781.cancelled)); + break; + } + case _Tag7236.entitiesUnloadEvent: { + ref wit.pumpkin.plugin.event.common.EntitiesUnloadEventData _payload6783 = _ret.getEntitiesUnloadEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(99); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6783.chunkX)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6783.chunkZ)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(_payload6783.entityCount); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload6783.cancelled)); + break; + } + case _Tag7236.genericGameEvent: { + ref wit.pumpkin.plugin.event.common.GenericGameEventData _payload6785 = _ret.getGenericGameEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(100); + *cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(size_t)(_payload6785.eventId.length); + *cast(void**)(_retArea.ptr + 8) = cast(void*)(cast(void*)(_payload6785.eventId.ptr)); + *cast(double*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(double)(_payload6785.pos[0]); + *cast(double*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(double)(_payload6785.pos[1]); + *cast(double*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(double)(_payload6785.pos[2]); + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6785.cancelled)); + break; + } + case _Tag7236.lootGenerateEvent: { + ref wit.pumpkin.plugin.event.common.LootGenerateEventData _payload6787 = _ret.getLootGenerateEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(101); + *cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(size_t)(_payload6787.lootTable.length); + *cast(void**)(_retArea.ptr + 8) = cast(void*)(cast(void*)(_payload6787.lootTable.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6787.cancelled)); + break; + } + case _Tag7236.portalCreateEvent: { + ref wit.pumpkin.plugin.event.common.PortalCreateEventData _payload6789 = _ret.getPortalCreateEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(102); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6789.pos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6789.pos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6789.pos.z)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload6789.portalType.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6789.portalType.ptr)); + *cast(ubyte*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6789.cancelled)); + break; + } + case _Tag7236.structureGrowEvent: { + ref wit.pumpkin.plugin.event.common.StructureGrowEventData _payload6791 = _ret.getStructureGrowEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(103); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6791.pos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6791.pos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6791.pos.z)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload6791.species.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6791.species.ptr)); + *cast(ubyte*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6791.boneMeal)); + *cast(ubyte*)(_retArea.ptr + (17+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6791.cancelled)); + break; + } + case _Tag7236.timeSkipEvent: { + ref wit.pumpkin.plugin.event.common.TimeSkipEventData _payload6793 = _ret.getTimeSkipEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(104); + *cast(ulong*)(_retArea.ptr + 8) = cast(ulong)(cast(ulong)(_payload6793.skipAmount)); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload6793.cancelled)); + break; + } + case _Tag7236.worldInitEvent: { + ref wit.pumpkin.plugin.event.imports.WorldInitEventData _payload6795 = _ret.getWorldInitEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(105); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6795.targetWorld.__handle); + break; + } + case _Tag7236.worldSaveEvent: { + ref wit.pumpkin.plugin.event.common.WorldSaveEventData _payload6797 = _ret.getWorldSaveEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(106); + *cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(size_t)(_payload6797.worldName.length); + *cast(void**)(_retArea.ptr + 8) = cast(void*)(cast(void*)(_payload6797.worldName.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6797.cancelled)); + break; + } + case _Tag7236.inventoryOpenEvent: { + ref wit.pumpkin.plugin.event.imports.InventoryOpenEventData _payload6799 = _ret.getInventoryOpenEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(107); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6799.player.__handle); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload6799.cancelled)); + break; + } + case _Tag7236.inventoryDragEvent: { + ref wit.pumpkin.plugin.event.imports.InventoryDragEventData _payload6801 = _ret.getInventoryDragEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(108); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6801.player.__handle); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload6801.cancelled)); + break; + } + case _Tag7236.craftItemEvent: { + ref wit.pumpkin.plugin.event.imports.CraftItemEventData _payload6803 = _ret.getCraftItemEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(109); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6803.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload6803.recipeId.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6803.recipeId.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6803.cancelled)); + break; + } + case _Tag7236.furnaceSmeltEvent: { + ref wit.pumpkin.plugin.event.common.FurnaceSmeltEventData _payload6805 = _ret.getFurnaceSmeltEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(110); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6805.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6805.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6805.blockPos.z)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload6805.sourceItem.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6805.sourceItem.ptr)); + *cast(size_t*)(_retArea.ptr + (16+4*size_t.sizeof)) = cast(size_t)(_payload6805.resultItem.length); + *cast(void**)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6805.resultItem.ptr)); + *cast(ubyte*)(_retArea.ptr + (16+5*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6805.cancelled)); + break; + } + case _Tag7236.brewEvent: { + ref wit.pumpkin.plugin.event.common.BrewEventData _payload6807 = _ret.getBrewEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(111); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6807.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6807.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6807.blockPos.z)); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload6807.fuelLevel)); + *cast(ubyte*)(_retArea.ptr + 21) = cast(ubyte)(cast(uint)(_payload6807.cancelled)); + break; + } + case _Tag7236.brewingStandFuelEvent: { + ref wit.pumpkin.plugin.event.common.BrewingStandFuelEventData _payload6809 = _ret.getBrewingStandFuelEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(112); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6809.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6809.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6809.blockPos.z)); + *cast(ushort*)(_retArea.ptr + 20) = cast(ushort)(cast(uint)(_payload6809.fuelPower)); + *cast(ubyte*)(_retArea.ptr + 22) = cast(ubyte)(cast(uint)(_payload6809.cancelled)); + break; + } + case _Tag7236.furnaceBurnEvent: { + ref wit.pumpkin.plugin.event.common.FurnaceBurnEventData _payload6811 = _ret.getFurnaceBurnEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(113); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6811.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6811.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6811.blockPos.z)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload6811.fuelItem.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6811.fuelItem.ptr)); + *cast(uint*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(uint)(_payload6811.burnTime); + *cast(ubyte*)(_retArea.ptr + (20+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6811.cancelled)); + break; + } + case _Tag7236.furnaceExtractEvent: { + ref wit.pumpkin.plugin.event.imports.FurnaceExtractEventData _payload6813 = _ret.getFurnaceExtractEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(114); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6813.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6813.blockPos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6813.blockPos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6813.blockPos.z)); + *cast(size_t*)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(size_t)(_payload6813.itemId.length); + *cast(void**)(_retArea.ptr + 24) = cast(void*)(cast(void*)(_payload6813.itemId.ptr)); + *cast(uint*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(uint)(_payload6813.itemAmount); + *cast(float*)(_retArea.ptr + (28+2*size_t.sizeof)) = cast(float)(_payload6813.expGained); + break; + } + case _Tag7236.furnaceStartSmeltEvent: { + ref wit.pumpkin.plugin.event.common.FurnaceStartSmeltEventData _payload6815 = _ret.getFurnaceStartSmeltEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(115); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6815.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6815.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6815.blockPos.z)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload6815.sourceItem.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6815.sourceItem.ptr)); + *cast(uint*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(uint)(_payload6815.cookingTime); + *cast(ubyte*)(_retArea.ptr + (20+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6815.cancelled)); + break; + } + case _Tag7236.hopperInventorySearchEvent: { + ref wit.pumpkin.plugin.event.common.HopperInventorySearchEventData _payload6817 = _ret.getHopperInventorySearchEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(116); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6817.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6817.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6817.blockPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6817.searchPos.x)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload6817.searchPos.y)); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload6817.searchPos.z)); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6817.cancelled)); + break; + } + case _Tag7236.inventoryCreativeEvent: { + ref wit.pumpkin.plugin.event.imports.InventoryCreativeEventData _payload6819 = _ret.getInventoryCreativeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(117); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6819.player.__handle); + *cast(ushort*)(_retArea.ptr + 12) = cast(ushort)(cast(uint)(_payload6819.slot)); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload6819.itemId.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload6819.itemId.ptr)); + *cast(ubyte*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6819.itemCount)); + *cast(ubyte*)(_retArea.ptr + (17+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6819.cancelled)); + break; + } + case _Tag7236.inventoryInteractEvent: { + ref wit.pumpkin.plugin.event.imports.InventoryInteractEventData _payload6821 = _ret.getInventoryInteractEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(118); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6821.player.__handle); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload6821.cancelled)); + break; + } + case _Tag7236.inventoryMoveItemEvent: { + ref wit.pumpkin.plugin.event.common.InventoryMoveItemEventData _payload6823 = _ret.getInventoryMoveItemEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(119); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6823.sourcePos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6823.sourcePos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6823.sourcePos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6823.targetPos.x)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload6823.targetPos.y)); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload6823.targetPos.z)); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6823.itemId.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6823.itemId.ptr)); + *cast(uint*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(uint)(_payload6823.itemAmount); + *cast(ubyte*)(_retArea.ptr + (36+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6823.cancelled)); + break; + } + case _Tag7236.inventoryPickupItemEvent: { + ref wit.pumpkin.plugin.event.common.InventoryPickupItemEventData _payload6825 = _ret.getInventoryPickupItemEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(120); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6825.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6825.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6825.blockPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6825.itemEntityId)); + *cast(size_t*)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(size_t)(_payload6825.itemId.length); + *cast(void**)(_retArea.ptr + 24) = cast(void*)(cast(void*)(_payload6825.itemId.ptr)); + *cast(ubyte*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6825.cancelled)); + break; + } + case _Tag7236.prepareAnvilEvent: { + ref wit.pumpkin.plugin.event.imports.PrepareAnvilEventData _payload6827 = _ret.getPrepareAnvilEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(121); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6827.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload6827.renameText.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6827.renameText.ptr)); + *cast(uint*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(uint)(_payload6827.repairCost); + break; + } + case _Tag7236.prepareGrindstoneEvent: { + ref wit.pumpkin.plugin.event.imports.PrepareGrindstoneEventData _payload6829 = _ret.getPrepareGrindstoneEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(122); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6829.player.__handle); + if (_payload6829.resultItem.isSome) { + ref _payload6833 = _payload6829.resultItem.unwrap(); + *cast(ubyte*)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(size_t)(_payload6833.length); + *cast(void**)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6833.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag7236.prepareInventoryResultEvent: { + ref wit.pumpkin.plugin.event.imports.PrepareInventoryResultEventData _payload6835 = _ret.getPrepareInventoryResultEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(123); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6835.player.__handle); + if (_payload6835.resultItem.isSome) { + ref _payload6839 = _payload6835.resultItem.unwrap(); + *cast(ubyte*)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(size_t)(_payload6839.length); + *cast(void**)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6839.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag7236.prepareItemCraftEvent: { + ref wit.pumpkin.plugin.event.imports.PrepareItemCraftEventData _payload6841 = _ret.getPrepareItemCraftEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(124); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6841.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload6841.recipeId.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6841.recipeId.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6841.cancelled)); + break; + } + case _Tag7236.prepareSmithingEvent: { + ref wit.pumpkin.plugin.event.imports.PrepareSmithingEventData _payload6843 = _ret.getPrepareSmithingEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(125); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6843.player.__handle); + if (_payload6843.resultItem.isSome) { + ref _payload6847 = _payload6843.resultItem.unwrap(); + *cast(ubyte*)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(size_t)(_payload6847.length); + *cast(void**)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6847.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag7236.smithItemEvent: { + ref wit.pumpkin.plugin.event.imports.SmithItemEventData _payload6849 = _ret.getSmithItemEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(126); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6849.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload6849.recipeId.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6849.recipeId.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6849.cancelled)); + break; + } + case _Tag7236.tradeSelectEvent: { + ref wit.pumpkin.plugin.event.imports.TradeSelectEventData _payload6851 = _ret.getTradeSelectEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(127); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6851.player.__handle); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload6851.slotIndex)); + *cast(ubyte*)(_retArea.ptr + 13) = cast(ubyte)(cast(uint)(_payload6851.cancelled)); + break; + } + case _Tag7236.vehicleBlockCollisionEvent: { + ref wit.pumpkin.plugin.event.common.VehicleBlockCollisionEventData _payload6853 = _ret.getVehicleBlockCollisionEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(128); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6853.vehicleId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6853.blockPos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6853.blockPos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6853.blockPos.z)); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload6853.cancelled)); + break; + } + case _Tag7236.vehicleCollisionEvent: { + ref wit.pumpkin.plugin.event.common.VehicleCollisionEventData _payload6855 = _ret.getVehicleCollisionEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(129); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6855.vehicleId)); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload6855.cancelled)); + break; + } + case _Tag7236.vehicleCreateEvent: { + ref wit.pumpkin.plugin.event.common.VehicleCreateEventData _payload6857 = _ret.getVehicleCreateEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(130); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6857.vehicleId)); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload6857.cancelled)); + break; + } + case _Tag7236.vehicleDamageEvent: { + ref wit.pumpkin.plugin.event.common.VehicleDamageEventData _payload6859 = _ret.getVehicleDamageEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(131); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6859.vehicleId)); + *cast(float*)(_retArea.ptr + 12) = cast(float)(_payload6859.damage); + if (_payload6859.attackerId.isSome) { + ref _payload6863 = _payload6859.attackerId.unwrap(); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6863)); + } else { + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload6859.cancelled)); + break; + } + case _Tag7236.vehicleDestroyEvent: { + ref wit.pumpkin.plugin.event.common.VehicleDestroyEventData _payload6865 = _ret.getVehicleDestroyEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(132); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6865.vehicleId)); + if (_payload6865.attackerId.isSome) { + ref _payload6869 = _payload6865.attackerId.unwrap(); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6869)); + } else { + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload6865.cancelled)); + break; + } + case _Tag7236.vehicleEnterEvent: { + ref wit.pumpkin.plugin.event.common.VehicleEnterEventData _payload6871 = _ret.getVehicleEnterEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(133); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6871.vehicleId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6871.enteredId)); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload6871.cancelled)); + break; + } + case _Tag7236.vehicleEntityCollisionEvent: { + ref wit.pumpkin.plugin.event.common.VehicleEntityCollisionEventData _payload6873 = _ret.getVehicleEntityCollisionEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(134); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6873.vehicleId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6873.collidedEntityId)); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload6873.cancelled)); + break; + } + case _Tag7236.vehicleExitEvent: { + ref wit.pumpkin.plugin.event.common.VehicleExitEventData _payload6875 = _ret.getVehicleExitEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(135); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6875.vehicleId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6875.exitedId)); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload6875.cancelled)); + break; + } + case _Tag7236.vehicleMoveEvent: { + ref wit.pumpkin.plugin.event.common.VehicleMoveEventData _payload6877 = _ret.getVehicleMoveEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(136); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6877.vehicleId)); + *cast(double*)(_retArea.ptr + 16) = cast(double)(_payload6877.fromPosition[0]); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload6877.fromPosition[1]); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload6877.fromPosition[2]); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload6877.toPosition[0]); + *cast(double*)(_retArea.ptr + 48) = cast(double)(_payload6877.toPosition[1]); + *cast(double*)(_retArea.ptr + 56) = cast(double)(_payload6877.toPosition[2]); + *cast(ubyte*)(_retArea.ptr + 64) = cast(ubyte)(cast(uint)(_payload6877.cancelled)); + break; + } + case _Tag7236.vehicleUpdateEvent: { + ref wit.pumpkin.plugin.event.common.VehicleUpdateEventData _payload6879 = _ret.getVehicleUpdateEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(137); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6879.vehicleId)); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload6879.cancelled)); + break; + } + case _Tag7236.prepareItemEnchantEvent: { + ref wit.pumpkin.plugin.event.imports.PrepareItemEnchantEventData _payload6881 = _ret.getPrepareItemEnchantEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(138); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6881.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(_payload6881.item.__handle); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload6881.offers.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload6881.offers.ptr)); + *cast(uint*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6881.bookshelfCount)); + *cast(ubyte*)(_retArea.ptr + (20+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6881.cancelled)); + break; + } + case _Tag7236.enchantItemEvent: { + ref wit.pumpkin.plugin.event.imports.EnchantItemEventData _payload6883 = _ret.getEnchantItemEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(139); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6883.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(_payload6883.item.__handle); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6883.option)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6883.cost)); + auto _listSrc6885 = _payload6883.enchantmentsToAdd; + auto _list6885 = _listSrc6885.length ? wit.common.malloc(_listSrc6885.length * (8)) : null; + assert(!_listSrc6885.length || _list6885); + foreach (_elem6884_idx, ref _elem6884; _listSrc6885) { + auto _base6884 = _list6885 + _elem6884_idx * (8); + *cast(ubyte*)(_base6884 + 0) = cast(ubyte)(cast(uint)(_elem6884.enchantment)); + *cast(uint*)(_base6884 + 4) = cast(uint)(_elem6884.level); + + } + if (_listSrc6885.length) wit.common.free(_listSrc6885.ptr); + *cast(size_t*)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(size_t)(_payload6883.enchantmentsToAdd.length); + *cast(void**)(_retArea.ptr + 24) = cast(void*)(_list6885); + *cast(ubyte*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6883.cancelled)); + break; + } + case _Tag7236.mapInitializeEvent: { + ref wit.pumpkin.plugin.event.common.MapInitializeEventData _payload6887 = _ret.getMapInitializeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(140); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6887.mapId)); + break; + } + case _Tag7236.hangingBreakEvent: { + ref wit.pumpkin.plugin.event.common.HangingBreakEventData _payload6889 = _ret.getHangingBreakEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(141); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6889.entityId)); + if (_payload6889.removerEntityId.isSome) { + ref _payload6893 = _payload6889.removerEntityId.unwrap(); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6893)); + } else { + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload6889.cancelled)); + break; + } + case _Tag7236.hangingBreakByEntityEvent: { + ref wit.pumpkin.plugin.event.common.HangingBreakByEntityEventData _payload6895 = _ret.getHangingBreakByEntityEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(142); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6895.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6895.removerEntityId)); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload6895.cancelled)); + break; + } + case _Tag7236.hangingPlaceEvent: { + ref wit.pumpkin.plugin.event.imports.HangingPlaceEventData _payload6897 = _ret.getHangingPlaceEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(143); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6897.entityId)); + if (_payload6897.player.isSome) { + ref _payload6901 = _payload6897.player.unwrap(); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(_payload6901.__handle); + } else { + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(0); + } + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6897.blockPos.x)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload6897.blockPos.y)); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload6897.blockPos.z)); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6897.blockFace.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6897.blockFace.ptr)); + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6897.cancelled)); + break; + } + case _Tag7236.bellResonateEvent: { + ref wit.pumpkin.plugin.event.imports.BellResonateEventData _payload6903 = _ret.getBellResonateEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(144); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6903.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6903.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6903.blockPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(_payload6903.targetWorld.__handle); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload6903.cancelled)); + break; + } + case _Tag7236.bellRingEvent: { + ref wit.pumpkin.plugin.event.imports.BellRingEventData _payload6905 = _ret.getBellRingEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(145); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6905.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6905.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6905.blockPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(_payload6905.targetWorld.__handle); + if (_payload6905.entityId.isSome) { + ref _payload6909 = _payload6905.entityId.unwrap(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload6909)); + } else { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(0); + } + if (_payload6905.direction.isSome) { + ref _payload6913 = _payload6905.direction.unwrap(); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(size_t)(_payload6913.length); + *cast(void**)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6913.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6905.cancelled)); + break; + } + case _Tag7236.blockBrushEvent: { + ref wit.pumpkin.plugin.event.imports.BlockBrushEventData _payload6915 = _ret.getBlockBrushEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(146); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6915.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6915.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6915.blockPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(_payload6915.targetWorld.__handle); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(_payload6915.player.__handle); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(_payload6915.item.__handle); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6915.cancelled)); + break; + } + case _Tag7236.blockCookEvent: { + ref wit.pumpkin.plugin.event.imports.BlockCookEventData _payload6917 = _ret.getBlockCookEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(147); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6917.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6917.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6917.blockPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(_payload6917.targetWorld.__handle); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(_payload6917.source.__handle); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(_payload6917.result.__handle); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6917.cancelled)); + break; + } + case _Tag7236.blockDamageAbortEvent: { + ref wit.pumpkin.plugin.event.imports.BlockDamageAbortEventData _payload6919 = _ret.getBlockDamageAbortEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(148); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6919.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6919.blockPos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6919.blockPos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6919.blockPos.z)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(_payload6919.targetWorld.__handle); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(_payload6919.itemInHand.__handle); + break; + } + case _Tag7236.blockDispenseArmorEvent: { + ref wit.pumpkin.plugin.event.imports.BlockDispenseArmorEventData _payload6921 = _ret.getBlockDispenseArmorEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(149); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6921.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6921.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6921.blockPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(_payload6921.targetWorld.__handle); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload6921.targetEntityId)); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(_payload6921.item.__handle); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6921.cancelled)); + break; + } + case _Tag7236.blockDispenseLootEvent: { + ref wit.pumpkin.plugin.event.imports.BlockDispenseLootEventData _payload6923 = _ret.getBlockDispenseLootEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(150); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6923.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6923.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6923.blockPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(_payload6923.targetWorld.__handle); + *cast(size_t*)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(size_t)(_payload6923.items.length); + *cast(void**)(_retArea.ptr + 24) = cast(void*)(cast(void*)(_payload6923.items.ptr)); + *cast(ubyte*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6923.cancelled)); + break; + } + case _Tag7236.blockDropItemEvent: { + ref wit.pumpkin.plugin.event.imports.BlockDropItemEventData _payload6925 = _ret.getBlockDropItemEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(151); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6925.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6925.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6925.blockPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(_payload6925.targetWorld.__handle); + if (_payload6925.player.isSome) { + ref _payload6929 = _payload6925.player.unwrap(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(_payload6929.__handle); + } else { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(0); + } + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6925.items.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6925.items.ptr)); + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6925.cancelled)); + break; + } + case _Tag7236.blockExpEvent: { + ref wit.pumpkin.plugin.event.imports.BlockExpEventData _payload6931 = _ret.getBlockExpEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(152); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6931.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6931.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6931.blockPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(_payload6931.targetWorld.__handle); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload6931.exp)); + break; + } + case _Tag7236.blockFertilizeEvent: { + ref wit.pumpkin.plugin.event.imports.BlockFertilizeEventData _payload6933 = _ret.getBlockFertilizeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(153); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6933.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6933.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6933.blockPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(_payload6933.targetWorld.__handle); + if (_payload6933.player.isSome) { + ref _payload6937 = _payload6933.player.unwrap(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(_payload6937.__handle); + } else { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(0); + } + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6933.changedBlocks.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6933.changedBlocks.ptr)); + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6933.cancelled)); + break; + } + case _Tag7236.blockMultiPlaceEvent: { + ref wit.pumpkin.plugin.event.imports.BlockMultiPlaceEventData _payload6939 = _ret.getBlockMultiPlaceEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(154); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload6939.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(_payload6939.targetWorld.__handle); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload6939.placedBlocks.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload6939.placedBlocks.ptr)); + *cast(ubyte*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6939.cancelled)); + break; + } + case _Tag7236.blockReceiveGameEvent: { + ref wit.pumpkin.plugin.event.imports.BlockReceiveGameEventData _payload6941 = _ret.getBlockReceiveGameEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(155); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6941.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6941.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6941.blockPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(_payload6941.targetWorld.__handle); + *cast(size_t*)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(size_t)(_payload6941.gameEvent.length); + *cast(void**)(_retArea.ptr + 24) = cast(void*)(cast(void*)(_payload6941.gameEvent.ptr)); + if (_payload6941.sourceEntityId.isSome) { + ref _payload6945 = _payload6941.sourceEntityId.unwrap(); + *cast(ubyte*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (28+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6945)); + } else { + *cast(ubyte*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6941.cancelled)); + break; + } + case _Tag7236.blockShearEntityEvent: { + ref wit.pumpkin.plugin.event.imports.BlockShearEntityEventData _payload6947 = _ret.getBlockShearEntityEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(156); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6947.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6947.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6947.blockPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(_payload6947.targetWorld.__handle); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload6947.targetEntityId)); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(_payload6947.item.__handle); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload6947.cancelled)); + break; + } + case _Tag7236.blockSpreadEvent: { + ref wit.pumpkin.plugin.event.imports.BlockSpreadEventData _payload6949 = _ret.getBlockSpreadEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(157); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6949.sourcePos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6949.sourcePos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6949.sourcePos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6949.targetPos.x)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload6949.targetPos.y)); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload6949.targetPos.z)); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(_payload6949.targetWorld.__handle); + *cast(ushort*)(_retArea.ptr + 36) = cast(ushort)(cast(uint)(_payload6949.newStateId)); + *cast(ubyte*)(_retArea.ptr + 38) = cast(ubyte)(cast(uint)(_payload6949.cancelled)); + break; + } + case _Tag7236.brewingStartEvent: { + ref wit.pumpkin.plugin.event.imports.BrewingStartEventData _payload6951 = _ret.getBrewingStartEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(158); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6951.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6951.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6951.blockPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(_payload6951.targetWorld.__handle); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload6951.brewingTime)); + *cast(ubyte*)(_retArea.ptr + 28) = cast(ubyte)(cast(uint)(_payload6951.cancelled)); + break; + } + case _Tag7236.campfireStartEvent: { + ref wit.pumpkin.plugin.event.imports.CampfireStartEventData _payload6953 = _ret.getCampfireStartEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(159); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6953.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6953.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6953.blockPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(_payload6953.targetWorld.__handle); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(_payload6953.item.__handle); + *cast(ubyte*)(_retArea.ptr + 28) = cast(ubyte)(cast(uint)(_payload6953.slot)); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload6953.cookingTime)); + *cast(ubyte*)(_retArea.ptr + 36) = cast(ubyte)(cast(uint)(_payload6953.cancelled)); + break; + } + case _Tag7236.cauldronLevelChangeEvent: { + ref wit.pumpkin.plugin.event.imports.CauldronLevelChangeEventData _payload6955 = _ret.getCauldronLevelChangeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(160); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6955.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6955.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6955.blockPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(_payload6955.targetWorld.__handle); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload6955.oldLevel)); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload6955.newLevel)); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6955.reason.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6955.reason.ptr)); + if (_payload6955.entityId.isSome) { + ref _payload6959 = _payload6955.entityId.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (36+2*size_t.sizeof)) = cast(uint)(cast(uint)(_payload6959)); + } else { + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6955.cancelled)); + break; + } + case _Tag7236.crafterCraftEvent: { + ref wit.pumpkin.plugin.event.imports.CrafterCraftEventData _payload6961 = _ret.getCrafterCraftEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(161); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6961.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6961.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6961.blockPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(_payload6961.targetWorld.__handle); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(_payload6961.result.__handle); + *cast(ubyte*)(_retArea.ptr + 28) = cast(ubyte)(cast(uint)(_payload6961.cancelled)); + break; + } + case _Tag7236.entityBlockFormEvent: { + ref wit.pumpkin.plugin.event.imports.EntityBlockFormEventData _payload6963 = _ret.getEntityBlockFormEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(162); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6963.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6963.blockPos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6963.blockPos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6963.blockPos.z)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(_payload6963.targetWorld.__handle); + *cast(ushort*)(_retArea.ptr + 28) = cast(ushort)(cast(uint)(_payload6963.newStateId)); + *cast(ubyte*)(_retArea.ptr + 30) = cast(ubyte)(cast(uint)(_payload6963.cancelled)); + break; + } + case _Tag7236.fluidLevelChangeEvent: { + ref wit.pumpkin.plugin.event.imports.FluidLevelChangeEventData _payload6965 = _ret.getFluidLevelChangeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(163); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6965.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6965.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6965.blockPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(_payload6965.targetWorld.__handle); + *cast(ushort*)(_retArea.ptr + 24) = cast(ushort)(cast(uint)(_payload6965.newStateId)); + *cast(ubyte*)(_retArea.ptr + 26) = cast(ubyte)(cast(uint)(_payload6965.cancelled)); + break; + } + case _Tag7236.inventoryBlockStartEvent: { + ref wit.pumpkin.plugin.event.imports.InventoryBlockStartEventData _payload6967 = _ret.getInventoryBlockStartEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(164); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6967.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6967.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6967.blockPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(_payload6967.targetWorld.__handle); + break; + } + case _Tag7236.leavesDecayEvent: { + ref wit.pumpkin.plugin.event.imports.LeavesDecayEventData _payload6969 = _ret.getLeavesDecayEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(165); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6969.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6969.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6969.blockPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(_payload6969.targetWorld.__handle); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload6969.cancelled)); + break; + } + case _Tag7236.moistureChangeEvent: { + ref wit.pumpkin.plugin.event.imports.MoistureChangeEventData _payload6971 = _ret.getMoistureChangeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(166); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6971.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6971.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6971.blockPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(_payload6971.targetWorld.__handle); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload6971.newMoisture)); + *cast(ubyte*)(_retArea.ptr + 28) = cast(ubyte)(cast(uint)(_payload6971.cancelled)); + break; + } + case _Tag7236.sculkBloomEvent: { + ref wit.pumpkin.plugin.event.imports.SculkBloomEventData _payload6973 = _ret.getSculkBloomEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(167); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6973.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6973.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6973.blockPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(_payload6973.targetWorld.__handle); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload6973.charge)); + *cast(ubyte*)(_retArea.ptr + 28) = cast(ubyte)(cast(uint)(_payload6973.cancelled)); + break; + } + case _Tag7236.vaultDisplayItemEvent: { + ref wit.pumpkin.plugin.event.imports.VaultDisplayItemEventData _payload6975 = _ret.getVaultDisplayItemEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(168); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6975.blockPos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6975.blockPos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6975.blockPos.z)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(_payload6975.targetWorld.__handle); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(_payload6975.item.__handle); + *cast(ubyte*)(_retArea.ptr + 28) = cast(ubyte)(cast(uint)(_payload6975.cancelled)); + break; + } + case _Tag7236.creatureSpawnEvent: { + ref wit.pumpkin.plugin.event.imports.CreatureSpawnEventData _payload6977 = _ret.getCreatureSpawnEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(169); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6977.entityId)); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload6977.entityType.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6977.entityType.ptr)); + *cast(double*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(double)(_payload6977.position[0]); + *cast(double*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(double)(_payload6977.position[1]); + *cast(double*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(double)(_payload6977.position[2]); + *cast(uint*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(uint)(_payload6977.targetWorld.__handle); + *cast(size_t*)(_retArea.ptr + (40+4*size_t.sizeof)) = cast(size_t)(_payload6977.spawnReason.length); + *cast(void**)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6977.spawnReason.ptr)); + *cast(ubyte*)(_retArea.ptr + (40+5*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6977.cancelled)); + break; + } + case _Tag7236.enderDragonChangePhaseEvent: { + ref wit.pumpkin.plugin.event.common.EnderDragonChangePhaseEventData _payload6979 = _ret.getEnderDragonChangePhaseEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(170); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6979.entityId)); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload6979.currentPhase.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6979.currentPhase.ptr)); + *cast(size_t*)(_retArea.ptr + (8+4*size_t.sizeof)) = cast(size_t)(_payload6979.newPhase.length); + *cast(void**)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6979.newPhase.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+5*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6979.cancelled)); + break; + } + case _Tag7236.entityBreakDoorEvent: { + ref wit.pumpkin.plugin.event.common.EntityBreakDoorEventData _payload6981 = _ret.getEntityBreakDoorEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(171); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6981.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6981.blockPos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6981.blockPos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6981.blockPos.z)); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload6981.cancelled)); + break; + } + case _Tag7236.entityChangeBlockEvent: { + ref wit.pumpkin.plugin.event.common.EntityChangeBlockEventData _payload6983 = _ret.getEntityChangeBlockEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(172); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6983.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6983.blockPos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6983.blockPos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6983.blockPos.z)); + *cast(size_t*)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(size_t)(_payload6983.newBlock.length); + *cast(void**)(_retArea.ptr + 24) = cast(void*)(cast(void*)(_payload6983.newBlock.ptr)); + *cast(ubyte*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6983.cancelled)); + break; + } + case _Tag7236.entityDamageByBlockEvent: { + ref wit.pumpkin.plugin.event.common.EntityDamageByBlockEventData _payload6985 = _ret.getEntityDamageByBlockEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(173); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6985.entityId)); + if (_payload6985.damagerPos.isSome) { + ref _payload6989 = _payload6985.damagerPos.unwrap(); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6989.x)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6989.y)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload6989.z)); + } else { + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(0); + } + *cast(float*)(_retArea.ptr + 28) = cast(float)(_payload6985.damage); + *cast(size_t*)(_retArea.ptr + (32+1*size_t.sizeof)) = cast(size_t)(_payload6985.cause.length); + *cast(void**)(_retArea.ptr + 32) = cast(void*)(cast(void*)(_payload6985.cause.ptr)); + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6985.cancelled)); + break; + } + case _Tag7236.entityDamageByEntityEvent: { + ref wit.pumpkin.plugin.event.common.EntityDamageByEntityEventData _payload6991 = _ret.getEntityDamageByEntityEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(174); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6991.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6991.damagerId)); + *cast(float*)(_retArea.ptr + 16) = cast(float)(_payload6991.damage); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload6991.cause.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6991.cause.ptr)); + *cast(ubyte*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6991.cancelled)); + break; + } + case _Tag7236.entityDropItemEvent: { + ref wit.pumpkin.plugin.event.common.EntityDropItemEventData _payload6993 = _ret.getEntityDropItemEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(175); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6993.entityId)); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload6993.itemName.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6993.itemName.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6993.count)); + *cast(ubyte*)(_retArea.ptr + (9+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload6993.cancelled)); + break; + } + case _Tag7236.entityEnterBlockEvent: { + ref wit.pumpkin.plugin.event.common.EntityEnterBlockEventData _payload6995 = _ret.getEntityEnterBlockEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(176); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6995.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6995.blockPos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6995.blockPos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6995.blockPos.z)); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload6995.cancelled)); + break; + } + case _Tag7236.entityExhaustionEvent: { + ref wit.pumpkin.plugin.event.common.EntityExhaustionEventData _payload6997 = _ret.getEntityExhaustionEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(177); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6997.entityId)); + *cast(float*)(_retArea.ptr + 12) = cast(float)(_payload6997.exhaustion); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload6997.cancelled)); + break; + } + case _Tag7236.entityInteractEvent: { + ref wit.pumpkin.plugin.event.common.EntityInteractEventData _payload6999 = _ret.getEntityInteractEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(178); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload6999.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload6999.blockPos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload6999.blockPos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload6999.blockPos.z)); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload6999.cancelled)); + break; + } + case _Tag7236.entityKnockbackEvent: { + ref wit.pumpkin.plugin.event.common.EntityKnockbackEventData _payload7001 = _ret.getEntityKnockbackEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(179); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7001.entityId)); + if (_payload7001.hitById.isSome) { + ref _payload7005 = _payload7001.hitById.unwrap(); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7005)); + } else { + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(0); + } + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload7001.knockback[0]); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload7001.knockback[1]); + *cast(double*)(_retArea.ptr + 40) = cast(double)(_payload7001.knockback[2]); + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(cast(uint)(_payload7001.cancelled)); + break; + } + case _Tag7236.entityPlaceEvent: { + ref wit.pumpkin.plugin.event.common.EntityPlaceEventData _payload7007 = _ret.getEntityPlaceEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(180); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7007.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7007.blockPos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7007.blockPos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload7007.blockPos.z)); + *cast(size_t*)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(size_t)(_payload7007.blockName.length); + *cast(void**)(_retArea.ptr + 24) = cast(void*)(cast(void*)(_payload7007.blockName.ptr)); + *cast(ubyte*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7007.cancelled)); + break; + } + case _Tag7236.entityPoseChangeEvent: { + ref wit.pumpkin.plugin.event.common.EntityPoseChangeEventData _payload7009 = _ret.getEntityPoseChangeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(181); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7009.entityId)); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7009.pose.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7009.pose.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7009.cancelled)); + break; + } + case _Tag7236.entityPotionEffectEvent: { + ref wit.pumpkin.plugin.event.common.EntityPotionEffectEventData _payload7011 = _ret.getEntityPotionEffectEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(182); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7011.entityId)); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7011.effectName.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7011.effectName.ptr)); + *cast(uint*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload7011.duration)); + *cast(ubyte*)(_retArea.ptr + (12+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7011.amplifier)); + *cast(ubyte*)(_retArea.ptr + (13+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7011.cancelled)); + break; + } + case _Tag7236.entitySpellCastEvent: { + ref wit.pumpkin.plugin.event.common.EntitySpellCastEventData _payload7013 = _ret.getEntitySpellCastEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(183); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7013.entityId)); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7013.spell.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7013.spell.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7013.cancelled)); + break; + } + case _Tag7236.entityTargetLivingEntityEvent: { + ref wit.pumpkin.plugin.event.common.EntityTargetLivingEntityEventData _payload7015 = _ret.getEntityTargetLivingEntityEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(184); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7015.entityId)); + if (_payload7015.targetId.isSome) { + ref _payload7019 = _payload7015.targetId.unwrap(); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7019)); + } else { + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(0); + } + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload7015.reason.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7015.reason.ptr)); + *cast(ubyte*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7015.cancelled)); + break; + } + case _Tag7236.entityToggleSwimEvent: { + ref wit.pumpkin.plugin.event.common.EntityToggleSwimEventData _payload7021 = _ret.getEntityToggleSwimEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(185); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7021.entityId)); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload7021.isSwimming)); + *cast(ubyte*)(_retArea.ptr + 13) = cast(ubyte)(cast(uint)(_payload7021.cancelled)); + break; + } + case _Tag7236.explosionPrimeEvent: { + ref wit.pumpkin.plugin.event.common.ExplosionPrimeEventData _payload7023 = _ret.getExplosionPrimeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(186); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7023.entityId)); + *cast(float*)(_retArea.ptr + 12) = cast(float)(_payload7023.radius); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload7023.fire)); + *cast(ubyte*)(_retArea.ptr + 17) = cast(ubyte)(cast(uint)(_payload7023.cancelled)); + break; + } + case _Tag7236.fireworkExplodeEvent: { + ref wit.pumpkin.plugin.event.common.FireworkExplodeEventData _payload7025 = _ret.getFireworkExplodeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(187); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7025.entityId)); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload7025.cancelled)); + break; + } + case _Tag7236.foodLevelChangeEvent: { + ref wit.pumpkin.plugin.event.common.FoodLevelChangeEventData _payload7027 = _ret.getFoodLevelChangeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(188); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7027.entityId)); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload7027.foodLevel)); + *cast(ubyte*)(_retArea.ptr + 13) = cast(ubyte)(cast(uint)(_payload7027.cancelled)); + break; + } + case _Tag7236.itemDespawnEvent: { + ref wit.pumpkin.plugin.event.common.ItemDespawnEventData _payload7029 = _ret.getItemDespawnEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(189); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7029.entityId)); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload7029.cancelled)); + break; + } + case _Tag7236.itemMergeEvent: { + ref wit.pumpkin.plugin.event.common.ItemMergeEventData _payload7031 = _ret.getItemMergeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(190); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7031.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7031.targetId)); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload7031.cancelled)); + break; + } + case _Tag7236.itemSpawnEvent: { + ref wit.pumpkin.plugin.event.common.ItemSpawnEventData _payload7033 = _ret.getItemSpawnEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(191); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7033.entityId)); + *cast(double*)(_retArea.ptr + 16) = cast(double)(_payload7033.position[0]); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload7033.position[1]); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload7033.position[2]); + *cast(size_t*)(_retArea.ptr + (40+1*size_t.sizeof)) = cast(size_t)(_payload7033.itemName.length); + *cast(void**)(_retArea.ptr + 40) = cast(void*)(cast(void*)(_payload7033.itemName.ptr)); + *cast(ubyte*)(_retArea.ptr + (40+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7033.cancelled)); + break; + } + case _Tag7236.piglinBarterEvent: { + ref wit.pumpkin.plugin.event.imports.PiglinBarterEventData _payload7035 = _ret.getPiglinBarterEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(192); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7035.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(_payload7035.inputItem.__handle); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload7035.outcome.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload7035.outcome.ptr)); + *cast(ubyte*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7035.cancelled)); + break; + } + case _Tag7236.projectileHitEvent: { + ref wit.pumpkin.plugin.event.common.ProjectileHitEventData _payload7037 = _ret.getProjectileHitEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(193); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7037.entityId)); + *cast(double*)(_retArea.ptr + 16) = cast(double)(_payload7037.hitPosition[0]); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload7037.hitPosition[1]); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload7037.hitPosition[2]); + if (_payload7037.hitEntityId.isSome) { + ref _payload7041 = _payload7037.hitEntityId.unwrap(); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 44) = cast(uint)(cast(uint)(_payload7041)); + } else { + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + 48) = cast(ubyte)(cast(uint)(_payload7037.cancelled)); + break; + } + case _Tag7236.projectileLaunchEvent: { + ref wit.pumpkin.plugin.event.common.ProjectileLaunchEventData _payload7043 = _ret.getProjectileLaunchEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(194); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7043.entityId)); + if (_payload7043.shooterId.isSome) { + ref _payload7047 = _payload7043.shooterId.unwrap(); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7047)); + } else { + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload7043.cancelled)); + break; + } + case _Tag7236.sheepDyeWoolEvent: { + ref wit.pumpkin.plugin.event.common.SheepDyeWoolEventData _payload7049 = _ret.getSheepDyeWoolEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(195); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7049.entityId)); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload7049.dyeColor)); + if (_payload7049.playerId.isSome) { + ref _payload7053 = _payload7049.playerId.unwrap(); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload7053)); + } else { + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload7049.cancelled)); + break; + } + case _Tag7236.sheepRegrowWoolEvent: { + ref wit.pumpkin.plugin.event.common.SheepRegrowWoolEventData _payload7055 = _ret.getSheepRegrowWoolEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(196); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7055.entityId)); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload7055.cancelled)); + break; + } + case _Tag7236.slimeSplitEvent: { + ref wit.pumpkin.plugin.event.common.SlimeSplitEventData _payload7057 = _ret.getSlimeSplitEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(197); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7057.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7057.count)); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload7057.cancelled)); + break; + } + case _Tag7236.striderTemperatureChangeEvent: { + ref wit.pumpkin.plugin.event.common.StriderTemperatureChangeEventData _payload7059 = _ret.getStriderTemperatureChangeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(198); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7059.entityId)); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload7059.isShivering)); + *cast(ubyte*)(_retArea.ptr + 13) = cast(ubyte)(cast(uint)(_payload7059.cancelled)); + break; + } + case _Tag7236.villagerAcquireTradeEvent: { + ref wit.pumpkin.plugin.event.common.VillagerAcquireTradeEventData _payload7061 = _ret.getVillagerAcquireTradeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(199); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7061.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7061.recipeIndex)); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload7061.cancelled)); + break; + } + case _Tag7236.villagerCareerChangeEvent: { + ref wit.pumpkin.plugin.event.common.VillagerCareerChangeEventData _payload7063 = _ret.getVillagerCareerChangeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(200); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7063.entityId)); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7063.profession.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7063.profession.ptr)); + *cast(size_t*)(_retArea.ptr + (8+4*size_t.sizeof)) = cast(size_t)(_payload7063.reason.length); + *cast(void**)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7063.reason.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+5*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7063.cancelled)); + break; + } + case _Tag7236.villagerReplenishTradeEvent: { + ref wit.pumpkin.plugin.event.common.VillagerReplenishTradeEventData _payload7065 = _ret.getVillagerReplenishTradeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(201); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7065.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7065.restockQuantity)); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload7065.cancelled)); + break; + } + case _Tag7236.wardenAngerChangeEvent: { + ref wit.pumpkin.plugin.event.common.WardenAngerChangeEventData _payload7067 = _ret.getWardenAngerChangeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(202); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7067.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7067.targetId)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7067.oldAnger)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload7067.newAnger)); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload7067.cancelled)); + break; + } + case _Tag7236.areaEffectCloudApplyEvent: { + ref wit.pumpkin.plugin.event.common.AreaEffectCloudApplyEventData _payload7069 = _ret.getAreaEffectCloudApplyEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(203); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7069.entityId)); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7069.affectedEntities.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7069.affectedEntities.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7069.cancelled)); + break; + } + case _Tag7236.arrowBodyCountChangeEvent: { + ref wit.pumpkin.plugin.event.common.ArrowBodyCountChangeEventData _payload7071 = _ret.getArrowBodyCountChangeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(204); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7071.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(_payload7071.oldAmount); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(_payload7071.newAmount); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload7071.cancelled)); + break; + } + case _Tag7236.batToggleSleepEvent: { + ref wit.pumpkin.plugin.event.common.BatToggleSleepEventData _payload7073 = _ret.getBatToggleSleepEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(205); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7073.entityId)); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload7073.isAwake)); + *cast(ubyte*)(_retArea.ptr + 13) = cast(ubyte)(cast(uint)(_payload7073.cancelled)); + break; + } + case _Tag7236.creeperPowerEvent: { + ref wit.pumpkin.plugin.event.common.CreeperPowerEventData _payload7075 = _ret.getCreeperPowerEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(206); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7075.entityId)); + if (_payload7075.lightningId.isSome) { + ref _payload7079 = _payload7075.lightningId.unwrap(); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7079)); + } else { + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(0); + } + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(_payload7075.cause.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7075.cause.ptr)); + *cast(ubyte*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7075.cancelled)); + break; + } + case _Tag7236.entityCombustByBlockEvent: { + ref wit.pumpkin.plugin.event.common.EntityCombustByBlockEventData _payload7081 = _ret.getEntityCombustByBlockEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(207); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7081.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7081.combuster.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7081.combuster.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload7081.combuster.z)); + *cast(float*)(_retArea.ptr + 24) = cast(float)(_payload7081.duration); + *cast(ubyte*)(_retArea.ptr + 28) = cast(ubyte)(cast(uint)(_payload7081.cancelled)); + break; + } + case _Tag7236.entityCombustByEntityEvent: { + ref wit.pumpkin.plugin.event.common.EntityCombustByEntityEventData _payload7083 = _ret.getEntityCombustByEntityEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(208); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7083.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7083.combusterId)); + *cast(float*)(_retArea.ptr + 16) = cast(float)(_payload7083.duration); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload7083.cancelled)); + break; + } + case _Tag7236.entityKnockbackByEntityEvent: { + ref wit.pumpkin.plugin.event.common.EntityKnockbackByEntityEventData _payload7085 = _ret.getEntityKnockbackByEntityEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(209); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7085.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7085.hitById)); + *cast(double*)(_retArea.ptr + 16) = cast(double)(_payload7085.force); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload7085.x); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload7085.z); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(cast(uint)(_payload7085.cancelled)); + break; + } + case _Tag7236.entityPortalEnterEvent: { + ref wit.pumpkin.plugin.event.common.EntityPortalEnterEventData _payload7087 = _ret.getEntityPortalEnterEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(210); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7087.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7087.location.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7087.location.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload7087.location.z)); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload7087.cancelled)); + break; + } + case _Tag7236.entityPortalExitEvent: { + ref wit.pumpkin.plugin.event.common.EntityPortalExitEventData _payload7089 = _ret.getEntityPortalExitEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(211); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7089.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7089.fromPos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7089.fromPos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload7089.fromPos.z)); + if (_payload7089.toPos.isSome) { + ref _payload7093 = _payload7089.toPos.unwrap(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload7093.x)); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload7093.y)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload7093.z)); + } else { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(cast(uint)(_payload7089.cancelled)); + break; + } + case _Tag7236.entityRemoveEvent: { + ref wit.pumpkin.plugin.event.common.EntityRemoveEventData _payload7095 = _ret.getEntityRemoveEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(212); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7095.entityId)); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7095.cause.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7095.cause.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7095.cancelled)); + break; + } + case _Tag7236.entityTargetBlockEvent: { + ref wit.pumpkin.plugin.event.common.EntityTargetBlockEventData _payload7097 = _ret.getEntityTargetBlockEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(213); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7097.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7097.blockPos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7097.blockPos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload7097.blockPos.z)); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload7097.cancelled)); + break; + } + case _Tag7236.entityUnleashEvent: { + ref wit.pumpkin.plugin.event.common.EntityUnleashEventData _payload7099 = _ret.getEntityUnleashEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(214); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7099.entityId)); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7099.reason.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7099.reason.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7099.cancelled)); + break; + } + case _Tag7236.expBottleEvent: { + ref wit.pumpkin.plugin.event.common.ExpBottleEventData _payload7101 = _ret.getExpBottleEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(215); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7101.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7101.experience)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7101.location.x)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload7101.location.y)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload7101.location.z)); + *cast(ubyte*)(_retArea.ptr + 28) = cast(ubyte)(cast(uint)(_payload7101.showEffect)); + *cast(ubyte*)(_retArea.ptr + 29) = cast(ubyte)(cast(uint)(_payload7101.cancelled)); + break; + } + case _Tag7236.horseJumpEvent: { + ref wit.pumpkin.plugin.event.common.HorseJumpEventData _payload7103 = _ret.getHorseJumpEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(216); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7103.entityId)); + *cast(float*)(_retArea.ptr + 12) = cast(float)(_payload7103.power); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload7103.cancelled)); + break; + } + case _Tag7236.lingeringPotionSplashEvent: { + ref wit.pumpkin.plugin.event.common.LingeringPotionSplashEventData _payload7105 = _ret.getLingeringPotionSplashEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(217); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7105.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7105.location.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7105.location.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload7105.location.z)); + *cast(size_t*)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(size_t)(_payload7105.potionItem.length); + *cast(void**)(_retArea.ptr + 24) = cast(void*)(cast(void*)(_payload7105.potionItem.ptr)); + *cast(ubyte*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7105.cancelled)); + break; + } + case _Tag7236.pigZapEvent: { + ref wit.pumpkin.plugin.event.common.PigZapEventData _payload7107 = _ret.getPigZapEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(218); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7107.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7107.lightningId)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7107.pigZombieId)); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload7107.cancelled)); + break; + } + case _Tag7236.pigZombieAngerEvent: { + ref wit.pumpkin.plugin.event.common.PigZombieAngerEventData _payload7109 = _ret.getPigZombieAngerEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(219); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7109.entityId)); + if (_payload7109.targetId.isSome) { + ref _payload7113 = _payload7109.targetId.unwrap(); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7113)); + } else { + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(0); + } + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload7109.newAnger)); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload7109.cancelled)); + break; + } + case _Tag7236.potionSplashEvent: { + ref wit.pumpkin.plugin.event.common.PotionSplashEventData _payload7115 = _ret.getPotionSplashEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(220); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7115.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7115.location.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7115.location.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload7115.location.z)); + *cast(size_t*)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(size_t)(_payload7115.potionItem.length); + *cast(void**)(_retArea.ptr + 24) = cast(void*)(cast(void*)(_payload7115.potionItem.ptr)); + *cast(size_t*)(_retArea.ptr + (24+3*size_t.sizeof)) = cast(size_t)(_payload7115.affectedEntities.length); + *cast(void**)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7115.affectedEntities.ptr)); + *cast(ubyte*)(_retArea.ptr + (24+4*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7115.cancelled)); + break; + } + case _Tag7236.spawnerSpawnEvent: { + ref wit.pumpkin.plugin.event.common.SpawnerSpawnEventData _payload7117 = _ret.getSpawnerSpawnEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(221); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7117.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7117.spawnerPos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7117.spawnerPos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload7117.spawnerPos.z)); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload7117.cancelled)); + break; + } + case _Tag7236.trialSpawnerSpawnEvent: { + ref wit.pumpkin.plugin.event.common.TrialSpawnerSpawnEventData _payload7119 = _ret.getTrialSpawnerSpawnEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(222); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7119.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7119.spawnerPos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7119.spawnerPos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload7119.spawnerPos.z)); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload7119.cancelled)); + break; + } + case _Tag7236.villagerReputationChangeEvent: { + ref wit.pumpkin.plugin.event.common.VillagerReputationChangeEventData _payload7121 = _ret.getVillagerReputationChangeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(223); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7121.entityId)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7121.targetId)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7121.reputationChange)); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload7121.cancelled)); + break; + } + case _Tag7236.asyncPlayerChatEvent: { + ref wit.pumpkin.plugin.event.imports.AsyncPlayerChatEventData _payload7123 = _ret.getAsyncPlayerChatEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(224); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7123.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7123.message.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7123.message.ptr)); + *cast(uint*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(uint)(_payload7123.format.__handle); + *cast(ubyte*)(_retArea.ptr + (12+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7123.cancelled)); + break; + } + case _Tag7236.asyncPlayerPreLoginEvent: { + ref wit.pumpkin.plugin.event.imports.AsyncPlayerPreLoginEventData _payload7125 = _ret.getAsyncPlayerPreLoginEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(225); + *cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(size_t)(_payload7125.playerName.length); + *cast(void**)(_retArea.ptr + 8) = cast(void*)(cast(void*)(_payload7125.playerName.ptr)); + *cast(size_t*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(size_t)(_payload7125.playerUuid.length); + *cast(void**)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7125.playerUuid.ptr)); + *cast(size_t*)(_retArea.ptr + (8+5*size_t.sizeof)) = cast(size_t)(_payload7125.ipAddress.length); + *cast(void**)(_retArea.ptr + (8+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7125.ipAddress.ptr)); + *cast(uint*)(_retArea.ptr + (8+6*size_t.sizeof)) = cast(uint)(_payload7125.kickMessage.__handle); + *cast(ubyte*)(_retArea.ptr + (12+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7125.cancelled)); + break; + } + case _Tag7236.playerAdvancementDoneEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerAdvancementDoneEventData _payload7127 = _ret.getPlayerAdvancementDoneEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(226); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7127.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7127.advancementId.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7127.advancementId.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7127.cancelled)); + break; + } + case _Tag7236.playerAnimationEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerAnimationEventData _payload7129 = _ret.getPlayerAnimationEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(227); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7129.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7129.animationType.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7129.animationType.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7129.cancelled)); + break; + } + case _Tag7236.playerArmorStandManipulateEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerArmorStandManipulateEventData _payload7131 = _ret.getPlayerArmorStandManipulateEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(228); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7131.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7131.armorStandId)); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload7131.slot)); + *cast(ubyte*)(_retArea.ptr + 17) = cast(ubyte)(cast(uint)(_payload7131.cancelled)); + break; + } + case _Tag7236.playerBucketEntityEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerBucketEntityEventData _payload7133 = _ret.getPlayerBucketEntityEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(229); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7133.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7133.entityId)); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload7133.bucketItem.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(cast(void*)(_payload7133.bucketItem.ptr)); + *cast(ubyte*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7133.cancelled)); + break; + } + case _Tag7236.playerChangedWorldEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerChangedWorldEventData _payload7135 = _ret.getPlayerChangedWorldEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(230); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7135.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(_payload7135.fromWorld.__handle); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(_payload7135.toWorld.__handle); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload7135.cancelled)); + break; + } + case _Tag7236.playerChannelEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerChannelEventData _payload7137 = _ret.getPlayerChannelEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(231); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7137.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7137.channel.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7137.channel.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7137.cancelled)); + break; + } + case _Tag7236.playerCommandPreprocessEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerCommandPreprocessEventData _payload7139 = _ret.getPlayerCommandPreprocessEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(232); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7139.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7139.command.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7139.command.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7139.cancelled)); + break; + } + case _Tag7236.playerEditBookEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerEditBookEventData _payload7141 = _ret.getPlayerEditBookEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(233); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7141.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(_payload7141.slot); + auto _listSrc7143 = _payload7141.pages; + auto _list7143 = _listSrc7143.length ? wit.common.malloc(_listSrc7143.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc7143.length || _list7143); + foreach (_elem7142_idx, ref _elem7142; _listSrc7143) { + auto _base7142 = _list7143 + _elem7142_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base7142 + size_t.sizeof) = cast(size_t)(_elem7142.length); + *cast(void**)(_base7142 + 0) = cast(void*)(cast(void*)(_elem7142.ptr)); + + } + if (_listSrc7143.length) wit.common.free(_listSrc7143.ptr); + *cast(size_t*)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(size_t)(_payload7141.pages.length); + *cast(void**)(_retArea.ptr + 16) = cast(void*)(_list7143); + if (_payload7141.title.isSome) { + ref _payload7147 = _payload7141.title.unwrap(); + *cast(ubyte*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (16+4*size_t.sizeof)) = cast(size_t)(_payload7147.length); + *cast(void**)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7147.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + (16+5*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7141.signing)); + *cast(ubyte*)(_retArea.ptr + (17+5*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7141.cancelled)); + break; + } + case _Tag7236.playerElytraBoostEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerElytraBoostEventData _payload7149 = _ret.getPlayerElytraBoostEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(234); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7149.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7149.fireworkId)); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload7149.cancelled)); + break; + } + case _Tag7236.playerExpCooldownChangeEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerExpCooldownChangeEventData _payload7151 = _ret.getPlayerExpCooldownChangeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(235); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7151.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7151.newCooldown)); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload7151.cancelled)); + break; + } + case _Tag7236.playerHarvestBlockEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerHarvestBlockEventData _payload7153 = _ret.getPlayerHarvestBlockEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(236); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7153.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7153.blockPos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7153.blockPos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload7153.blockPos.z)); + *cast(size_t*)(_retArea.ptr + (24+1*size_t.sizeof)) = cast(size_t)(_payload7153.harvestedItems.length); + *cast(void**)(_retArea.ptr + 24) = cast(void*)(cast(void*)(_payload7153.harvestedItems.ptr)); + *cast(ubyte*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7153.cancelled)); + break; + } + case _Tag7236.playerHideEntityEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerHideEntityEventData _payload7155 = _ret.getPlayerHideEntityEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(237); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7155.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7155.entityId)); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload7155.cancelled)); + break; + } + case _Tag7236.playerItemBreakEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerItemBreakEventData _payload7157 = _ret.getPlayerItemBreakEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(238); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7157.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7157.itemName.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7157.itemName.ptr)); + break; + } + case _Tag7236.playerItemMendEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerItemMendEventData _payload7159 = _ret.getPlayerItemMendEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(239); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7159.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7159.itemName.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7159.itemName.ptr)); + *cast(uint*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload7159.repairAmount)); + *cast(uint*)(_retArea.ptr + (12+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload7159.expConsumed)); + *cast(ubyte*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7159.cancelled)); + break; + } + case _Tag7236.playerKickEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerKickEventData _payload7161 = _ret.getPlayerKickEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(240); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7161.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7161.reason.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7161.reason.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7161.cancelled)); + break; + } + case _Tag7236.playerLeashEntityEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerLeashEntityEventData _payload7163 = _ret.getPlayerLeashEntityEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(241); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7163.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7163.entityId)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7163.holderId)); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload7163.cancelled)); + break; + } + case _Tag7236.playerLevelChangeEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerLevelChangeEventData _payload7165 = _ret.getPlayerLevelChangeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(242); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7165.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7165.oldLevel)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7165.newLevel)); + break; + } + case _Tag7236.playerLocaleChangeEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerLocaleChangeEventData _payload7167 = _ret.getPlayerLocaleChangeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(243); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7167.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7167.newLocale.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7167.newLocale.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7167.cancelled)); + break; + } + case _Tag7236.playerNameEntityEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerNameEntityEventData _payload7169 = _ret.getPlayerNameEntityEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(244); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7169.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7169.entityId)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(_payload7169.name.__handle); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload7169.cancelled)); + break; + } + case _Tag7236.playerOpenSignEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerOpenSignEventData _payload7171 = _ret.getPlayerOpenSignEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(245); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7171.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7171.blockPos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7171.blockPos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload7171.blockPos.z)); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload7171.isFront)); + *cast(ubyte*)(_retArea.ptr + 25) = cast(ubyte)(cast(uint)(_payload7171.cancelled)); + break; + } + case _Tag7236.playerPortalEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerPortalEventData _payload7173 = _ret.getPlayerPortalEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(246); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7173.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7173.fromPos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7173.fromPos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload7173.fromPos.z)); + if (_payload7173.toPos.isSome) { + ref _payload7177 = _payload7173.toPos.unwrap(); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 28) = cast(uint)(cast(uint)(_payload7177.x)); + *cast(uint*)(_retArea.ptr + 32) = cast(uint)(cast(uint)(_payload7177.y)); + *cast(uint*)(_retArea.ptr + 36) = cast(uint)(cast(uint)(_payload7177.z)); + } else { + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(cast(uint)(_payload7173.cancelled)); + break; + } + case _Tag7236.playerPreLoginEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerPreLoginEventData _payload7179 = _ret.getPlayerPreLoginEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(247); + *cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(size_t)(_payload7179.playerName.length); + *cast(void**)(_retArea.ptr + 8) = cast(void*)(cast(void*)(_payload7179.playerName.ptr)); + *cast(size_t*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(size_t)(_payload7179.playerUuid.length); + *cast(void**)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7179.playerUuid.ptr)); + *cast(size_t*)(_retArea.ptr + (8+5*size_t.sizeof)) = cast(size_t)(_payload7179.ipAddress.length); + *cast(void**)(_retArea.ptr + (8+4*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7179.ipAddress.ptr)); + *cast(uint*)(_retArea.ptr + (8+6*size_t.sizeof)) = cast(uint)(_payload7179.kickMessage.__handle); + *cast(ubyte*)(_retArea.ptr + (12+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7179.cancelled)); + break; + } + case _Tag7236.playerRiptideEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerRiptideEventData _payload7181 = _ret.getPlayerRiptideEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(248); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7181.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7181.itemName.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7181.itemName.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7181.cancelled)); + break; + } + case _Tag7236.playerShearEntityEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerShearEntityEventData _payload7183 = _ret.getPlayerShearEntityEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(249); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7183.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7183.entityId)); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload7183.hand)); + *cast(ubyte*)(_retArea.ptr + 17) = cast(ubyte)(cast(uint)(_payload7183.cancelled)); + break; + } + case _Tag7236.playerShowEntityEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerShowEntityEventData _payload7185 = _ret.getPlayerShowEntityEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(250); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7185.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7185.entityId)); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload7185.cancelled)); + break; + } + case _Tag7236.playerSpawnChangeEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerSpawnChangeEventData _payload7187 = _ret.getPlayerSpawnChangeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(251); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7187.player.__handle); + if (_payload7187.newSpawn.isSome) { + ref _payload7191 = _payload7187.newSpawn.unwrap(); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7191.x)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload7191.y)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(cast(uint)(_payload7191.z)); + } else { + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + 28) = cast(ubyte)(cast(uint)(_payload7187.forced)); + *cast(ubyte*)(_retArea.ptr + 29) = cast(ubyte)(cast(uint)(_payload7187.cancelled)); + break; + } + case _Tag7236.playerStatisticIncrementEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerStatisticIncrementEventData _payload7193 = _ret.getPlayerStatisticIncrementEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(252); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7193.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7193.statisticId.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7193.statisticId.ptr)); + *cast(uint*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(uint)(cast(uint)(_payload7193.amount)); + *cast(ubyte*)(_retArea.ptr + (12+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7193.cancelled)); + break; + } + case _Tag7236.playerSwapHandsEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerSwapHandsEventData _payload7195 = _ret.getPlayerSwapHandsEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(253); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7195.player.__handle); + *cast(ubyte*)(_retArea.ptr + 12) = cast(ubyte)(cast(uint)(_payload7195.cancelled)); + break; + } + case _Tag7236.playerTakeLecternBookEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerTakeLecternBookEventData _payload7197 = _ret.getPlayerTakeLecternBookEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(254); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7197.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7197.blockPos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7197.blockPos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload7197.blockPos.z)); + *cast(uint*)(_retArea.ptr + 24) = cast(uint)(_payload7197.book.__handle); + *cast(ubyte*)(_retArea.ptr + 28) = cast(ubyte)(cast(uint)(_payload7197.cancelled)); + break; + } + case _Tag7236.playerUnleashEntityEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerUnleashEntityEventData _payload7199 = _ret.getPlayerUnleashEntityEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(255); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7199.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7199.entityId)); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload7199.cancelled)); + break; + } + case _Tag7236.playerVelocityEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerVelocityEventData _payload7201 = _ret.getPlayerVelocityEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(256); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7201.player.__handle); + *cast(double*)(_retArea.ptr + 16) = cast(double)(_payload7201.velocity[0]); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload7201.velocity[1]); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload7201.velocity[2]); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(cast(uint)(_payload7201.cancelled)); + break; + } + case _Tag7236.playerInputEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerInputEventData _payload7203 = _ret.getPlayerInputEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(257); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7203.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7203.input.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7203.input.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7203.cancelled)); + break; + } + case _Tag7236.playerInteractAtEntityEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerInteractAtEntityEventData _payload7205 = _ret.getPlayerInteractAtEntityEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(258); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7205.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7205.entityId)); + *cast(double*)(_retArea.ptr + 16) = cast(double)(_payload7205.clickedX); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload7205.clickedY); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload7205.clickedZ); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(cast(uint)(_payload7205.hand)); + *cast(ubyte*)(_retArea.ptr + 41) = cast(ubyte)(cast(uint)(_payload7205.cancelled)); + break; + } + case _Tag7236.playerLinksSendEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerLinksSendEventData _payload7207 = _ret.getPlayerLinksSendEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(259); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7207.player.__handle); + auto _listSrc7209 = _payload7207.links; + auto _list7209 = _listSrc7209.length ? wit.common.malloc(_listSrc7209.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc7209.length || _list7209); + foreach (_elem7208_idx, ref _elem7208; _listSrc7209) { + auto _base7208 = _list7209 + _elem7208_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base7208 + size_t.sizeof) = cast(size_t)(_elem7208.length); + *cast(void**)(_base7208 + 0) = cast(void*)(cast(void*)(_elem7208.ptr)); + + } + if (_listSrc7209.length) wit.common.free(_listSrc7209.ptr); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7207.links.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(_list7209); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7207.cancelled)); + break; + } + case _Tag7236.playerPickupArrowEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerPickupArrowEventData _payload7211 = _ret.getPlayerPickupArrowEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(260); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7211.player.__handle); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7211.arrowId)); + *cast(ubyte*)(_retArea.ptr + 16) = cast(ubyte)(cast(uint)(_payload7211.cancelled)); + break; + } + case _Tag7236.playerRecipeBookClickEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerRecipeBookClickEventData _payload7213 = _ret.getPlayerRecipeBookClickEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(261); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7213.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7213.recipeId.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7213.recipeId.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7213.makeAll)); + *cast(ubyte*)(_retArea.ptr + (9+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7213.cancelled)); + break; + } + case _Tag7236.playerRecipeBookSettingsChangeEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerRecipeBookSettingsChangeEventData _payload7215 = _ret.getPlayerRecipeBookSettingsChangeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(262); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7215.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7215.bookType.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7215.bookType.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7215.isOpen)); + *cast(ubyte*)(_retArea.ptr + (9+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7215.isFiltering)); + *cast(ubyte*)(_retArea.ptr + (10+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7215.cancelled)); + break; + } + case _Tag7236.playerRecipeDiscoverEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerRecipeDiscoverEventData _payload7217 = _ret.getPlayerRecipeDiscoverEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(263); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7217.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7217.recipeId.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7217.recipeId.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7217.cancelled)); + break; + } + case _Tag7236.playerRegisterChannelEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerRegisterChannelEventData _payload7219 = _ret.getPlayerRegisterChannelEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(264); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7219.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7219.channel.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7219.channel.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7219.cancelled)); + break; + } + case _Tag7236.playerResourcePackStatusEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerResourcePackStatusEventData _payload7221 = _ret.getPlayerResourcePackStatusEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(265); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7221.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7221.packId.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7221.packId.ptr)); + *cast(size_t*)(_retArea.ptr + (8+4*size_t.sizeof)) = cast(size_t)(_payload7221.status.length); + *cast(void**)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7221.status.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+5*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7221.cancelled)); + break; + } + case _Tag7236.playerSpawnLocationEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerSpawnLocationEventData _payload7223 = _ret.getPlayerSpawnLocationEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(266); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7223.player.__handle); + *cast(double*)(_retArea.ptr + 16) = cast(double)(_payload7223.spawnPos[0]); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload7223.spawnPos[1]); + *cast(double*)(_retArea.ptr + 32) = cast(double)(_payload7223.spawnPos[2]); + *cast(ubyte*)(_retArea.ptr + 40) = cast(ubyte)(cast(uint)(_payload7223.cancelled)); + break; + } + case _Tag7236.playerUnregisterChannelEvent: { + ref wit.pumpkin.plugin.event.imports.PlayerUnregisterChannelEventData _payload7225 = _ret.getPlayerUnregisterChannelEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(267); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7225.player.__handle); + *cast(size_t*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(size_t)(_payload7225.channel.length); + *cast(void**)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7225.channel.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7225.cancelled)); + break; + } + case _Tag7236.raidFinishEvent: { + ref wit.pumpkin.plugin.event.common.RaidFinishEventData _payload7227 = _ret.getRaidFinishEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(268); + *cast(ubyte*)(_retArea.ptr + 8) = cast(ubyte)(cast(uint)(_payload7227.victory)); + *cast(ubyte*)(_retArea.ptr + 9) = cast(ubyte)(cast(uint)(_payload7227.cancelled)); + break; + } + case _Tag7236.raidSpawnWaveEvent: { + ref wit.pumpkin.plugin.event.common.RaidSpawnWaveEventData _payload7229 = _ret.getRaidSpawnWaveEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(269); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(_payload7229.wave); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7229.pos.x)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7229.pos.y)); + *cast(uint*)(_retArea.ptr + 20) = cast(uint)(cast(uint)(_payload7229.pos.z)); + *cast(ubyte*)(_retArea.ptr + 24) = cast(ubyte)(cast(uint)(_payload7229.cancelled)); + break; + } + case _Tag7236.raidStopEvent: { + ref wit.pumpkin.plugin.event.common.RaidStopEventData _payload7231 = _ret.getRaidStopEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(270); + *cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(size_t)(_payload7231.reason.length); + *cast(void**)(_retArea.ptr + 8) = cast(void*)(cast(void*)(_payload7231.reason.ptr)); + *cast(ubyte*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload7231.cancelled)); + break; + } + case _Tag7236.raidTriggerEvent: { + ref wit.pumpkin.plugin.event.common.RaidTriggerEventData _payload7233 = _ret.getRaidTriggerEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(271); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(_payload7233.pos.x)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(_payload7233.pos.y)); + *cast(uint*)(_retArea.ptr + 16) = cast(uint)(cast(uint)(_payload7233.pos.z)); + *cast(ubyte*)(_retArea.ptr + 20) = cast(ubyte)(cast(uint)(_payload7233.cancelled)); + break; + } + case _Tag7236.lightningStrikeEvent: { + ref wit.pumpkin.plugin.event.common.LightningStrikeEventData _payload7235 = _ret.getLightningStrikeEvent(); + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(272); + *cast(double*)(_retArea.ptr + 8) = cast(double)(_payload7235.position[0]); + *cast(double*)(_retArea.ptr + 16) = cast(double)(_payload7235.position[1]); + *cast(double*)(_retArea.ptr + 24) = cast(double)(_payload7235.position[2]); + *cast(ubyte*)(_retArea.ptr + 32) = cast(ubyte)(cast(uint)(_payload7235.isEffect)); + *cast(ubyte*)(_retArea.ptr + 33) = cast(ubyte)(cast(uint)(_payload7235.cancelled)); + break; + } + } + return _retArea.ptr; + } + @wasmExport!("cabi_post_handle-event") + pragma(mangle, "__wit_cabi_post_handle_event") + private extern(C) void __cabi_post_handleEvent(void* arg0) { + switch (cast(uint)(*(cast(ushort*)(arg0 + 0)))) { + case 0: { + break; + } + case 1: { + break; + } + case 2: { + break; + } + case 3: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + auto _listSrcPtr5 = *(cast(void**)(arg0 + (8+3*size_t.sizeof))); + auto _listLen5 = *(cast(size_t*)(arg0 + (8+4*size_t.sizeof))); + foreach (_elem4_idx; 0.._listLen5) { + const auto _base4 = _listSrcPtr5 + _elem4_idx * 4; + + } + if (*(cast(size_t*)(arg0 + (8+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+3*size_t.sizeof)))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (8+5*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + auto _listSrcPtr9 = *(cast(void**)(arg0 + (8+6*size_t.sizeof))); + auto _listLen9 = *(cast(size_t*)(arg0 + (8+7*size_t.sizeof))); + foreach (_elem8_idx; 0.._listLen9) { + const auto _base8 = _listSrcPtr9 + _elem8_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (8+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+6*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 4: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 5: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 6: { + break; + } + case 7: { + break; + } + case 8: { + break; + } + case 9: { + break; + } + case 10: { + break; + } + case 11: { + break; + } + case 12: { + break; + } + case 13: { + break; + } + case 14: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + auto _listSrcPtr22 = *(cast(void**)(arg0 + (8+3*size_t.sizeof))); + auto _listLen22 = *(cast(size_t*)(arg0 + (8+4*size_t.sizeof))); + foreach (_elem21_idx; 0.._listLen22) { + const auto _base21 = _listSrcPtr22 + _elem21_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (8+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+3*size_t.sizeof)))); + } + break; + } + case 15: { + if (*(cast(size_t*)(arg0 + (40+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 40))); + } + break; + } + case 16: { + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + case 17: { + break; + } + case 18: { + break; + } + case 19: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 20: { + break; + } + case 21: { + break; + } + case 22: { + break; + } + case 23: { + break; + } + case 24: { + break; + } + case 25: { + break; + } + case 26: { + if (*(cast(size_t*)(arg0 + (16+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 16))); + } + break; + } + case 27: { + if (*(cast(size_t*)(arg0 + (8+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 8))); + } + if (*(cast(size_t*)(arg0 + (8+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+2*size_t.sizeof)))); + } + break; + } + case 28: { + if (*(cast(size_t*)(arg0 + (8+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 8))); + } + if (*(cast(size_t*)(arg0 + (16+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (16+2*size_t.sizeof)))); + } + break; + } + case 29: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (8+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+4*size_t.sizeof)))); + } + break; + } + case 30: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (8+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+3*size_t.sizeof)))); + } + break; + } + case 31: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (8+3*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + auto _listSrcPtr43 = *(cast(void**)(arg0 + (8+4*size_t.sizeof))); + auto _listLen43 = *(cast(size_t*)(arg0 + (8+5*size_t.sizeof))); + foreach (_elem42_idx; 0.._listLen43) { + const auto _base42 = _listSrcPtr43 + _elem42_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (8+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+4*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 32: { + auto _listSrcPtr46 = *(cast(void**)(arg0 + (16+1*size_t.sizeof))); + auto _listLen46 = *(cast(size_t*)(arg0 + (16+2*size_t.sizeof))); + foreach (_elem45_idx; 0.._listLen46) { + const auto _base45 = _listSrcPtr46 + _elem45_idx * 8; + + } + if (*(cast(size_t*)(arg0 + (16+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))); + } + auto _listSrcPtr56 = *(cast(void**)(arg0 + (16+3*size_t.sizeof))); + auto _listLen56 = *(cast(size_t*)(arg0 + (16+4*size_t.sizeof))); + foreach (_elem47_idx; 0.._listLen56) { + const auto _base47 = _listSrcPtr56 + _elem47_idx * (16+5*size_t.sizeof); + switch (cast(uint)(*(cast(ubyte*)(_base47 + 0)))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(_base47 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base47 + (8+1*size_t.sizeof)))); + } + break; + } + case 2: { + switch (cast(uint)(*(cast(ubyte*)(_base47 + (16+2*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(_base47 + (16+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base47 + (16+3*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 3: { + auto _listSrcPtr55 = *(cast(void**)(_base47 + (2*size_t.sizeof))); + auto _listLen55 = *(cast(size_t*)(_base47 + (3*size_t.sizeof))); + foreach (_elem54_idx; 0.._listLen55) { + const auto _base54 = _listSrcPtr55 + _elem54_idx * 4; + + } + if (*(cast(size_t*)(_base47 + (3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base47 + (2*size_t.sizeof)))); + } + break; + } + default: break; + } + + } + if (*(cast(size_t*)(arg0 + (16+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (16+3*size_t.sizeof)))); + } + auto _listSrcPtr64 = *(cast(void**)(arg0 + (16+5*size_t.sizeof))); + auto _listLen64 = *(cast(size_t*)(arg0 + (16+6*size_t.sizeof))); + foreach (_elem57_idx; 0.._listLen64) { + const auto _base57 = _listSrcPtr64 + _elem57_idx * (16+7*size_t.sizeof); + switch (cast(uint)(*(cast(ubyte*)(_base57 + (16+1*size_t.sizeof))))) { + case 0: { + if (*(cast(size_t*)(_base57 + (16+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base57 + (16+2*size_t.sizeof)))); + } + break; + } + case 1: { + if (*(cast(size_t*)(_base57 + (16+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base57 + (16+2*size_t.sizeof)))); + } + switch (cast(uint)(*(cast(ubyte*)(_base57 + (16+4*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + auto _listSrcPtr63 = *(cast(void**)(_base57 + (16+5*size_t.sizeof))); + auto _listLen63 = *(cast(size_t*)(_base57 + (16+6*size_t.sizeof))); + foreach (_elem62_idx; 0.._listLen63) { + const auto _base62 = _listSrcPtr63 + _elem62_idx * 1; + + } + if (*(cast(size_t*)(_base57 + (16+6*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base57 + (16+5*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + default: break; + } + + } + if (*(cast(size_t*)(arg0 + (16+6*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (16+5*size_t.sizeof)))); + } + auto _listSrcPtr66 = *(cast(void**)(arg0 + (16+7*size_t.sizeof))); + auto _listLen66 = *(cast(size_t*)(arg0 + (16+8*size_t.sizeof))); + foreach (_elem65_idx; 0.._listLen66) { + const auto _base65 = _listSrcPtr66 + _elem65_idx * (8+2*size_t.sizeof); + if (*(cast(size_t*)(_base65 + (8+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base65 + 8))); + } + + } + if (*(cast(size_t*)(arg0 + (16+8*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (16+7*size_t.sizeof)))); + } + break; + } + case 33: { + break; + } + case 34: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + 16)))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (16+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 35: { + if (*(cast(size_t*)(arg0 + (8+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 8))); + } + break; + } + case 36: { + if (*(cast(size_t*)(arg0 + (8+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 8))); + } + if (*(cast(size_t*)(arg0 + (8+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+2*size_t.sizeof)))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (16+6*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (16+8*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (16+7*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 37: { + break; + } + case 38: { + break; + } + case 39: { + break; + } + case 40: { + break; + } + case 41: { + break; + } + case 42: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + 16)))) { + case 0: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) { + case 0: { + break; + } + case 1: { + break; + } + case 2: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 3: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (32+3*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + auto _listSrcPtr89 = *(cast(void**)(arg0 + (32+4*size_t.sizeof))); + auto _listLen89 = *(cast(size_t*)(arg0 + (32+5*size_t.sizeof))); + foreach (_elem88_idx; 0.._listLen89) { + const auto _base88 = _listSrcPtr89 + _elem88_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (32+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+4*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 4: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (32+2*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + auto _listSrcPtr94 = *(cast(void**)(arg0 + (32+3*size_t.sizeof))); + auto _listLen94 = *(cast(size_t*)(arg0 + (32+4*size_t.sizeof))); + foreach (_elem93_idx; 0.._listLen94) { + const auto _base93 = _listSrcPtr94 + _elem93_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (32+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+3*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 5: { + break; + } + case 6: { + auto _listSrcPtr98 = *(cast(void**)(arg0 + 32)); + auto _listLen98 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem97_idx; 0.._listLen98) { + const auto _base97 = _listSrcPtr98 + _elem97_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base97 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base97 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 7: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + auto _listSrcPtr101 = *(cast(void**)(arg0 + (32+2*size_t.sizeof))); + auto _listLen101 = *(cast(size_t*)(arg0 + (32+3*size_t.sizeof))); + foreach (_elem100_idx; 0.._listLen101) { + const auto _base100 = _listSrcPtr101 + _elem100_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (32+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+2*size_t.sizeof)))); + } + break; + } + case 8: { + break; + } + case 9: { + break; + } + case 10: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (32+2*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + auto _listSrcPtr108 = *(cast(void**)(arg0 + (32+3*size_t.sizeof))); + auto _listLen108 = *(cast(size_t*)(arg0 + (32+4*size_t.sizeof))); + foreach (_elem107_idx; 0.._listLen108) { + const auto _base107 = _listSrcPtr108 + _elem107_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (32+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+3*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 11: { + break; + } + case 12: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 13: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + (32+1*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + auto _listSrcPtr115 = *(cast(void**)(arg0 + (32+2*size_t.sizeof))); + auto _listLen115 = *(cast(size_t*)(arg0 + (32+3*size_t.sizeof))); + foreach (_elem114_idx; 0.._listLen115) { + const auto _base114 = _listSrcPtr115 + _elem114_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (32+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+2*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 14: { + break; + } + case 15: { + break; + } + case 16: { + break; + } + case 17: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 18: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 19: { + break; + } + case 20: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 21: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + auto _listSrcPtr127 = *(cast(void**)(arg0 + (48+2*size_t.sizeof))); + auto _listLen127 = *(cast(size_t*)(arg0 + (48+3*size_t.sizeof))); + foreach (_elem124_idx; 0.._listLen127) { + const auto _base124 = _listSrcPtr127 + _elem124_idx * (4*size_t.sizeof); + if (*(cast(size_t*)(_base124 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base124 + 0))); + } + auto _listSrcPtr126 = *(cast(void**)(_base124 + (2*size_t.sizeof))); + auto _listLen126 = *(cast(size_t*)(_base124 + (3*size_t.sizeof))); + foreach (_elem125_idx; 0.._listLen126) { + const auto _base125 = _listSrcPtr126 + _elem125_idx * 1; + + } + if (*(cast(size_t*)(_base124 + (3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base124 + (2*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(arg0 + (48+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (48+2*size_t.sizeof)))); + } + auto _listSrcPtr129 = *(cast(void**)(arg0 + (48+5*size_t.sizeof))); + auto _listLen129 = *(cast(size_t*)(arg0 + (48+6*size_t.sizeof))); + foreach (_elem128_idx; 0.._listLen129) { + const auto _base128 = _listSrcPtr129 + _elem128_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (48+6*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (48+5*size_t.sizeof)))); + } + break; + } + case 22: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (48+2*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + auto _listSrcPtr134 = *(cast(void**)(arg0 + (48+3*size_t.sizeof))); + auto _listLen134 = *(cast(size_t*)(arg0 + (48+4*size_t.sizeof))); + foreach (_elem133_idx; 0.._listLen134) { + const auto _base133 = _listSrcPtr134 + _elem133_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (48+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (48+3*size_t.sizeof)))); + } + break; + } + default: break; + } + auto _listSrcPtr136 = *(cast(void**)(arg0 + (48+6*size_t.sizeof))); + auto _listLen136 = *(cast(size_t*)(arg0 + (48+7*size_t.sizeof))); + foreach (_elem135_idx; 0.._listLen136) { + const auto _base135 = _listSrcPtr136 + _elem135_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (48+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (48+6*size_t.sizeof)))); + } + break; + } + case 23: { + break; + } + case 24: { + auto _listSrcPtr140 = *(cast(void**)(arg0 + (48+1*size_t.sizeof))); + auto _listLen140 = *(cast(size_t*)(arg0 + (48+2*size_t.sizeof))); + foreach (_elem139_idx; 0.._listLen140) { + const auto _base139 = _listSrcPtr140 + _elem139_idx * (3*size_t.sizeof); + if (*(cast(size_t*)(_base139 + (2*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base139 + size_t.sizeof))); + } + + } + if (*(cast(size_t*)(arg0 + (48+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (48+1*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (48+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (48+3*size_t.sizeof)))); + } + break; + } + case 25: { + break; + } + case 26: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 27: { + break; + } + case 28: { + break; + } + case 29: { + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + case 30: { + break; + } + case 31: { + break; + } + case 32: { + break; + } + case 33: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (32+2*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + auto _listSrcPtr153 = *(cast(void**)(arg0 + (32+3*size_t.sizeof))); + auto _listLen153 = *(cast(size_t*)(arg0 + (32+4*size_t.sizeof))); + foreach (_elem152_idx; 0.._listLen153) { + const auto _base152 = _listSrcPtr153 + _elem152_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (32+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+3*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 34: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (32+2*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + auto _listSrcPtr158 = *(cast(void**)(arg0 + (32+3*size_t.sizeof))); + auto _listLen158 = *(cast(size_t*)(arg0 + (32+4*size_t.sizeof))); + foreach (_elem157_idx; 0.._listLen158) { + const auto _base157 = _listSrcPtr158 + _elem157_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (32+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+3*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 35: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + auto _listSrcPtr161 = *(cast(void**)(arg0 + (32+2*size_t.sizeof))); + auto _listLen161 = *(cast(size_t*)(arg0 + (32+3*size_t.sizeof))); + foreach (_elem160_idx; 0.._listLen161) { + const auto _base160 = _listSrcPtr161 + _elem160_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (32+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+2*size_t.sizeof)))); + } + break; + } + case 36: { + break; + } + case 37: { + break; + } + case 38: { + auto _listSrcPtr166 = *(cast(void**)(arg0 + (32+1*size_t.sizeof))); + auto _listLen166 = *(cast(size_t*)(arg0 + (32+2*size_t.sizeof))); + foreach (_elem165_idx; 0.._listLen166) { + const auto _base165 = _listSrcPtr166 + _elem165_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base165 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base165 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (32+3*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (32+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+4*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 39: { + break; + } + case 40: { + break; + } + case 41: { + break; + } + case 42: { + break; + } + case 43: { + break; + } + case 44: { + break; + } + case 45: { + break; + } + case 46: { + break; + } + case 47: { + break; + } + case 48: { + break; + } + case 49: { + break; + } + case 50: { + break; + } + case 51: { + break; + } + case 52: { + break; + } + case 53: { + break; + } + case 54: { + break; + } + case 55: { + break; + } + case 56: { + break; + } + case 57: { + break; + } + case 58: { + break; + } + case 59: { + auto _listSrcPtr191 = *(cast(void**)(arg0 + 56)); + auto _listLen191 = *(cast(size_t*)(arg0 + (56+1*size_t.sizeof))); + foreach (_elem190_idx; 0.._listLen191) { + const auto _base190 = _listSrcPtr191 + _elem190_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (56+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 56))); + } + auto _listSrcPtr193 = *(cast(void**)(arg0 + (56+2*size_t.sizeof))); + auto _listLen193 = *(cast(size_t*)(arg0 + (56+3*size_t.sizeof))); + foreach (_elem192_idx; 0.._listLen193) { + const auto _base192 = _listSrcPtr193 + _elem192_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (56+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (56+2*size_t.sizeof)))); + } + break; + } + case 60: { + break; + } + case 61: { + break; + } + case 62: { + break; + } + case 63: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 64: { + break; + } + case 65: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) { + case 0: { + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + case 1: { + break; + } + default: break; + } + break; + } + case 66: { + break; + } + case 67: { + break; + } + case 68: { + if (*(cast(size_t*)(arg0 + (40+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))); + } + break; + } + case 69: { + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + case 70: { + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + case 71: { + auto _listSrcPtr209 = *(cast(void**)(arg0 + 32)); + auto _listLen209 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem208_idx; 0.._listLen209) { + const auto _base208 = _listSrcPtr209 + _elem208_idx * (4*size_t.sizeof); + if (*(cast(size_t*)(_base208 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base208 + 0))); + } + if (*(cast(size_t*)(_base208 + (3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base208 + (2*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 72: { + break; + } + case 73: { + if (*(cast(size_t*)(arg0 + (40+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (40+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+3*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (40+6*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+5*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (40+8*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+7*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (40+10*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+9*size_t.sizeof)))); + } + break; + } + case 74: { + if (*(cast(size_t*)(arg0 + (48+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (48+1*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (64+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (64+3*size_t.sizeof)))); + } + break; + } + case 75: { + if (*(cast(size_t*)(arg0 + (48+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 48))); + } + break; + } + case 76: { + break; + } + case 77: { + break; + } + case 78: { + break; + } + case 79: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + 48)))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (48+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (48+1*size_t.sizeof)))); + } + break; + } + default: break; + } + if (*(cast(size_t*)(arg0 + (56+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (56+4*size_t.sizeof)))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (56+7*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (56+9*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (56+8*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 80: { + if (*(cast(size_t*)(arg0 + (48+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 48))); + } + if (*(cast(size_t*)(arg0 + (48+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (48+2*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (48+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (48+4*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (48+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (48+6*size_t.sizeof)))); + } + break; + } + case 81: { + break; + } + case 82: { + break; + } + case 83: { + break; + } + case 84: { + break; + } + case 85: { + break; + } + default: break; + } + break; + } + case 1: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) { + case 0: { + break; + } + case 1: { + break; + } + case 2: { + break; + } + case 3: { + auto _listSrcPtr234 = *(cast(void**)(arg0 + 32)); + auto _listLen234 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem233_idx; 0.._listLen234) { + const auto _base233 = _listSrcPtr234 + _elem233_idx * 8; + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + auto _listSrcPtr236 = *(cast(void**)(arg0 + (32+2*size_t.sizeof))); + auto _listLen236 = *(cast(size_t*)(arg0 + (32+3*size_t.sizeof))); + foreach (_elem235_idx; 0.._listLen236) { + const auto _base235 = _listSrcPtr236 + _elem235_idx * 8; + + } + if (*(cast(size_t*)(arg0 + (32+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+2*size_t.sizeof)))); + } + break; + } + case 4: { + break; + } + case 5: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + if (*(cast(size_t*)(arg0 + (32+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+2*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (48+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (48+4*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (56+8*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (56+7*size_t.sizeof)))); + } + break; + } + case 6: { + break; + } + case 7: { + if (*(cast(size_t*)(arg0 + (40+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 40))); + } + if (*(cast(size_t*)(arg0 + (40+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+3*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (40+6*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+5*size_t.sizeof)))); + } + break; + } + case 8: { + auto _listSrcPtr243 = *(cast(void**)(arg0 + 40)); + auto _listLen243 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + foreach (_elem242_idx; 0.._listLen243) { + const auto _base242 = _listSrcPtr243 + _elem242_idx * 16; + + } + if (*(cast(size_t*)(arg0 + (40+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 40))); + } + break; + } + case 9: { + break; + } + case 10: { + auto _listSrcPtr249 = *(cast(void**)(arg0 + (32+1*size_t.sizeof))); + auto _listLen249 = *(cast(size_t*)(arg0 + (32+2*size_t.sizeof))); + foreach (_elem246_idx; 0.._listLen249) { + const auto _base246 = _listSrcPtr249 + _elem246_idx * (3*size_t.sizeof); + auto _listSrcPtr248 = *(cast(void**)(_base246 + size_t.sizeof)); + auto _listLen248 = *(cast(size_t*)(_base246 + (2*size_t.sizeof))); + foreach (_elem247_idx; 0.._listLen248) { + const auto _base247 = _listSrcPtr248 + _elem247_idx * 1; + + } + if (*(cast(size_t*)(_base246 + (2*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base246 + size_t.sizeof))); + } + + } + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + auto _listSrcPtr259 = *(cast(void**)(arg0 + (32+4*size_t.sizeof))); + auto _listLen259 = *(cast(size_t*)(arg0 + (32+5*size_t.sizeof))); + foreach (_elem250_idx; 0.._listLen259) { + const auto _base250 = _listSrcPtr259 + _elem250_idx * (72+12*size_t.sizeof); + if (*(cast(size_t*)(_base250 + (40+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base250 + 40))); + } + auto _listSrcPtr252 = *(cast(void**)(_base250 + (40+2*size_t.sizeof))); + auto _listLen252 = *(cast(size_t*)(_base250 + (40+3*size_t.sizeof))); + foreach (_elem251_idx; 0.._listLen252) { + const auto _base251 = _listSrcPtr252 + _elem251_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base251 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base251 + 0))); + } + + } + if (*(cast(size_t*)(_base250 + (40+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base250 + (40+2*size_t.sizeof)))); + } + auto _listSrcPtr254 = *(cast(void**)(_base250 + (40+4*size_t.sizeof))); + auto _listLen254 = *(cast(size_t*)(_base250 + (40+5*size_t.sizeof))); + foreach (_elem253_idx; 0.._listLen254) { + const auto _base253 = _listSrcPtr254 + _elem253_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base253 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base253 + 0))); + } + + } + if (*(cast(size_t*)(_base250 + (40+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base250 + (40+4*size_t.sizeof)))); + } + if (*(cast(size_t*)(_base250 + (64+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base250 + (64+6*size_t.sizeof)))); + } + auto _listSrcPtr256 = *(cast(void**)(_base250 + (64+8*size_t.sizeof))); + auto _listLen256 = *(cast(size_t*)(_base250 + (64+9*size_t.sizeof))); + foreach (_elem255_idx; 0.._listLen256) { + const auto _base255 = _listSrcPtr256 + _elem255_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base255 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base255 + 0))); + } + + } + if (*(cast(size_t*)(_base250 + (64+9*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base250 + (64+8*size_t.sizeof)))); + } + auto _listSrcPtr258 = *(cast(void**)(_base250 + (64+10*size_t.sizeof))); + auto _listLen258 = *(cast(size_t*)(_base250 + (64+11*size_t.sizeof))); + foreach (_elem257_idx; 0.._listLen258) { + const auto _base257 = _listSrcPtr258 + _elem257_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base257 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base257 + 0))); + } + + } + if (*(cast(size_t*)(_base250 + (64+11*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base250 + (64+10*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(arg0 + (32+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+4*size_t.sizeof)))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (40+6*size_t.sizeof))))) { + case 0: { + if (*(cast(size_t*)(arg0 + (48+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (48+6*size_t.sizeof)))); + } + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (48+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (48+6*size_t.sizeof)))); + } + break; + } + case 2: { + if (*(cast(size_t*)(arg0 + (96+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (96+6*size_t.sizeof)))); + } + auto _listSrcPtr264 = *(cast(void**)(arg0 + (96+8*size_t.sizeof))); + auto _listLen264 = *(cast(size_t*)(arg0 + (96+9*size_t.sizeof))); + foreach (_elem263_idx; 0.._listLen264) { + const auto _base263 = _listSrcPtr264 + _elem263_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base263 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base263 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (96+9*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (96+8*size_t.sizeof)))); + } + auto _listSrcPtr266 = *(cast(void**)(arg0 + (96+10*size_t.sizeof))); + auto _listLen266 = *(cast(size_t*)(arg0 + (96+11*size_t.sizeof))); + foreach (_elem265_idx; 0.._listLen266) { + const auto _base265 = _listSrcPtr266 + _elem265_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base265 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base265 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (96+11*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (96+10*size_t.sizeof)))); + } + break; + } + case 3: { + if (*(cast(size_t*)(arg0 + (80+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (80+6*size_t.sizeof)))); + } + auto _listSrcPtr269 = *(cast(void**)(arg0 + (80+8*size_t.sizeof))); + auto _listLen269 = *(cast(size_t*)(arg0 + (80+9*size_t.sizeof))); + foreach (_elem268_idx; 0.._listLen269) { + const auto _base268 = _listSrcPtr269 + _elem268_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base268 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base268 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (80+9*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (80+8*size_t.sizeof)))); + } + auto _listSrcPtr271 = *(cast(void**)(arg0 + (80+10*size_t.sizeof))); + auto _listLen271 = *(cast(size_t*)(arg0 + (80+11*size_t.sizeof))); + foreach (_elem270_idx; 0.._listLen271) { + const auto _base270 = _listSrcPtr271 + _elem270_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base270 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base270 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (80+11*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (80+10*size_t.sizeof)))); + } + break; + } + case 4: { + if (*(cast(size_t*)(arg0 + (72+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (72+6*size_t.sizeof)))); + } + auto _listSrcPtr274 = *(cast(void**)(arg0 + (72+8*size_t.sizeof))); + auto _listLen274 = *(cast(size_t*)(arg0 + (72+9*size_t.sizeof))); + foreach (_elem273_idx; 0.._listLen274) { + const auto _base273 = _listSrcPtr274 + _elem273_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base273 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base273 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (72+9*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (72+8*size_t.sizeof)))); + } + auto _listSrcPtr276 = *(cast(void**)(arg0 + (72+10*size_t.sizeof))); + auto _listLen276 = *(cast(size_t*)(arg0 + (72+11*size_t.sizeof))); + foreach (_elem275_idx; 0.._listLen276) { + const auto _base275 = _listSrcPtr276 + _elem275_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base275 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base275 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (72+11*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (72+10*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 11: { + auto _listSrcPtr307 = *(cast(void**)(arg0 + 32)); + auto _listLen307 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem278_idx; 0.._listLen307) { + const auto _base278 = _listSrcPtr307 + _elem278_idx * (6*size_t.sizeof); + auto _listSrcPtr304 = *(cast(void**)(_base278 + size_t.sizeof)); + auto _listLen304 = *(cast(size_t*)(_base278 + (2*size_t.sizeof))); + foreach (_elem279_idx; 0.._listLen304) { + const auto _base279 = _listSrcPtr304 + _elem279_idx * (40+2*size_t.sizeof); + switch (cast(uint)(*(cast(ubyte*)(_base279 + 0)))) { + case 0: { + break; + } + case 1: { + break; + } + case 2: { + break; + } + case 3: { + break; + } + case 4: { + break; + } + case 5: { + break; + } + case 6: { + break; + } + case 7: { + break; + } + case 8: { + break; + } + case 9: { + break; + } + case 10: { + break; + } + case 11: { + break; + } + case 12: { + break; + } + case 13: { + break; + } + case 14: { + break; + } + case 15: { + if (*(cast(size_t*)(_base279 + (2*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base279 + size_t.sizeof))); + } + break; + } + case 16: { + break; + } + case 17: { + auto _listSrcPtr303 = *(cast(void**)(_base279 + size_t.sizeof)); + auto _listLen303 = *(cast(size_t*)(_base279 + (2*size_t.sizeof))); + foreach (_elem298_idx; 0.._listLen303) { + const auto _base298 = _listSrcPtr303 + _elem298_idx * (8+6*size_t.sizeof); + switch (cast(uint)(*(cast(ubyte*)(_base298 + 0)))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(_base298 + (2*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base298 + size_t.sizeof))); + } + break; + } + default: break; + } + auto _listSrcPtr302 = *(cast(void**)(_base298 + (8+4*size_t.sizeof))); + auto _listLen302 = *(cast(size_t*)(_base298 + (8+5*size_t.sizeof))); + foreach (_elem301_idx; 0.._listLen302) { + const auto _base301 = _listSrcPtr302 + _elem301_idx * 1; + + } + if (*(cast(size_t*)(_base298 + (8+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base298 + (8+4*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(_base279 + (2*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base279 + size_t.sizeof))); + } + break; + } + default: break; + } + + } + if (*(cast(size_t*)(_base278 + (2*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base278 + size_t.sizeof))); + } + auto _listSrcPtr306 = *(cast(void**)(_base278 + (3*size_t.sizeof))); + auto _listLen306 = *(cast(size_t*)(_base278 + (4*size_t.sizeof))); + foreach (_elem305_idx; 0.._listLen306) { + const auto _base305 = _listSrcPtr306 + _elem305_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base305 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base305 + 0))); + } + + } + if (*(cast(size_t*)(_base278 + (4*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base278 + (3*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 12: { + break; + } + case 13: { + auto _listSrcPtr311 = *(cast(void**)(arg0 + (32+1*size_t.sizeof))); + auto _listLen311 = *(cast(size_t*)(arg0 + (32+2*size_t.sizeof))); + foreach (_elem310_idx; 0.._listLen311) { + const auto _base310 = _listSrcPtr311 + _elem310_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + auto _listSrcPtr313 = *(cast(void**)(arg0 + (32+3*size_t.sizeof))); + auto _listLen313 = *(cast(size_t*)(arg0 + (32+4*size_t.sizeof))); + foreach (_elem312_idx; 0.._listLen313) { + const auto _base312 = _listSrcPtr313 + _elem312_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (32+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+3*size_t.sizeof)))); + } + break; + } + case 14: { + auto _listSrcPtr316 = *(cast(void**)(arg0 + 56)); + auto _listLen316 = *(cast(size_t*)(arg0 + (56+1*size_t.sizeof))); + foreach (_elem315_idx; 0.._listLen316) { + const auto _base315 = _listSrcPtr316 + _elem315_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (56+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 56))); + } + break; + } + case 15: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + (32+1*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (32+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+2*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 16: { + if (*(cast(size_t*)(arg0 + (40+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))); + } + break; + } + case 17: { + break; + } + case 18: { + auto _listSrcPtr324 = *(cast(void**)(arg0 + (80+1*size_t.sizeof))); + auto _listLen324 = *(cast(size_t*)(arg0 + (80+2*size_t.sizeof))); + foreach (_elem323_idx; 0.._listLen324) { + const auto _base323 = _listSrcPtr324 + _elem323_idx * 8; + + } + if (*(cast(size_t*)(arg0 + (80+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (80+1*size_t.sizeof)))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (128+4*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + auto _listSrcPtr328 = *(cast(void**)(arg0 + (128+5*size_t.sizeof))); + auto _listLen328 = *(cast(size_t*)(arg0 + (128+6*size_t.sizeof))); + foreach (_elem327_idx; 0.._listLen328) { + const auto _base327 = _listSrcPtr328 + _elem327_idx * 20; + + } + if (*(cast(size_t*)(arg0 + (128+6*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (128+5*size_t.sizeof)))); + } + break; + } + default: break; + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (136+6*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + auto _listSrcPtr334 = *(cast(void**)(arg0 + (144+7*size_t.sizeof))); + auto _listLen334 = *(cast(size_t*)(arg0 + (144+8*size_t.sizeof))); + foreach (_elem331_idx; 0.._listLen334) { + const auto _base331 = _listSrcPtr334 + _elem331_idx * (3*size_t.sizeof); + auto _listSrcPtr333 = *(cast(void**)(_base331 + size_t.sizeof)); + auto _listLen333 = *(cast(size_t*)(_base331 + (2*size_t.sizeof))); + foreach (_elem332_idx; 0.._listLen333) { + const auto _base332 = _listSrcPtr333 + _elem332_idx * 1; + + } + if (*(cast(size_t*)(_base331 + (2*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base331 + size_t.sizeof))); + } + + } + if (*(cast(size_t*)(arg0 + (144+8*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (144+7*size_t.sizeof)))); + } + auto _listSrcPtr344 = *(cast(void**)(arg0 + (144+9*size_t.sizeof))); + auto _listLen344 = *(cast(size_t*)(arg0 + (144+10*size_t.sizeof))); + foreach (_elem335_idx; 0.._listLen344) { + const auto _base335 = _listSrcPtr344 + _elem335_idx * (72+12*size_t.sizeof); + if (*(cast(size_t*)(_base335 + (40+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base335 + 40))); + } + auto _listSrcPtr337 = *(cast(void**)(_base335 + (40+2*size_t.sizeof))); + auto _listLen337 = *(cast(size_t*)(_base335 + (40+3*size_t.sizeof))); + foreach (_elem336_idx; 0.._listLen337) { + const auto _base336 = _listSrcPtr337 + _elem336_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base336 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base336 + 0))); + } + + } + if (*(cast(size_t*)(_base335 + (40+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base335 + (40+2*size_t.sizeof)))); + } + auto _listSrcPtr339 = *(cast(void**)(_base335 + (40+4*size_t.sizeof))); + auto _listLen339 = *(cast(size_t*)(_base335 + (40+5*size_t.sizeof))); + foreach (_elem338_idx; 0.._listLen339) { + const auto _base338 = _listSrcPtr339 + _elem338_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base338 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base338 + 0))); + } + + } + if (*(cast(size_t*)(_base335 + (40+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base335 + (40+4*size_t.sizeof)))); + } + if (*(cast(size_t*)(_base335 + (64+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base335 + (64+6*size_t.sizeof)))); + } + auto _listSrcPtr341 = *(cast(void**)(_base335 + (64+8*size_t.sizeof))); + auto _listLen341 = *(cast(size_t*)(_base335 + (64+9*size_t.sizeof))); + foreach (_elem340_idx; 0.._listLen341) { + const auto _base340 = _listSrcPtr341 + _elem340_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base340 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base340 + 0))); + } + + } + if (*(cast(size_t*)(_base335 + (64+9*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base335 + (64+8*size_t.sizeof)))); + } + auto _listSrcPtr343 = *(cast(void**)(_base335 + (64+10*size_t.sizeof))); + auto _listLen343 = *(cast(size_t*)(_base335 + (64+11*size_t.sizeof))); + foreach (_elem342_idx; 0.._listLen343) { + const auto _base342 = _listSrcPtr343 + _elem342_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base342 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base342 + 0))); + } + + } + if (*(cast(size_t*)(_base335 + (64+11*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base335 + (64+10*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(arg0 + (144+10*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (144+9*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (200+11*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (200+10*size_t.sizeof)))); + } + auto _listSrcPtr346 = *(cast(void**)(arg0 + (200+12*size_t.sizeof))); + auto _listLen346 = *(cast(size_t*)(arg0 + (200+13*size_t.sizeof))); + foreach (_elem345_idx; 0.._listLen346) { + const auto _base345 = _listSrcPtr346 + _elem345_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base345 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base345 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (200+13*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (200+12*size_t.sizeof)))); + } + auto _listSrcPtr348 = *(cast(void**)(arg0 + (200+14*size_t.sizeof))); + auto _listLen348 = *(cast(size_t*)(arg0 + (200+15*size_t.sizeof))); + foreach (_elem347_idx; 0.._listLen348) { + const auto _base347 = _listSrcPtr348 + _elem347_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base347 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base347 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (200+15*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (200+14*size_t.sizeof)))); + } + break; + } + default: break; + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (264+16*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + auto _listSrcPtr376 = *(cast(void**)(arg0 + (264+18*size_t.sizeof))); + auto _listLen376 = *(cast(size_t*)(arg0 + (264+19*size_t.sizeof))); + foreach (_elem351_idx; 0.._listLen376) { + const auto _base351 = _listSrcPtr376 + _elem351_idx * (40+2*size_t.sizeof); + switch (cast(uint)(*(cast(ubyte*)(_base351 + 0)))) { + case 0: { + break; + } + case 1: { + break; + } + case 2: { + break; + } + case 3: { + break; + } + case 4: { + break; + } + case 5: { + break; + } + case 6: { + break; + } + case 7: { + break; + } + case 8: { + break; + } + case 9: { + break; + } + case 10: { + break; + } + case 11: { + break; + } + case 12: { + break; + } + case 13: { + break; + } + case 14: { + break; + } + case 15: { + if (*(cast(size_t*)(_base351 + (2*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base351 + size_t.sizeof))); + } + break; + } + case 16: { + break; + } + case 17: { + auto _listSrcPtr375 = *(cast(void**)(_base351 + size_t.sizeof)); + auto _listLen375 = *(cast(size_t*)(_base351 + (2*size_t.sizeof))); + foreach (_elem370_idx; 0.._listLen375) { + const auto _base370 = _listSrcPtr375 + _elem370_idx * (8+6*size_t.sizeof); + switch (cast(uint)(*(cast(ubyte*)(_base370 + 0)))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(_base370 + (2*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base370 + size_t.sizeof))); + } + break; + } + default: break; + } + auto _listSrcPtr374 = *(cast(void**)(_base370 + (8+4*size_t.sizeof))); + auto _listLen374 = *(cast(size_t*)(_base370 + (8+5*size_t.sizeof))); + foreach (_elem373_idx; 0.._listLen374) { + const auto _base373 = _listSrcPtr374 + _elem373_idx * 1; + + } + if (*(cast(size_t*)(_base370 + (8+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base370 + (8+4*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(_base351 + (2*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base351 + size_t.sizeof))); + } + break; + } + default: break; + } + + } + if (*(cast(size_t*)(arg0 + (264+19*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (264+18*size_t.sizeof)))); + } + auto _listSrcPtr378 = *(cast(void**)(arg0 + (264+20*size_t.sizeof))); + auto _listLen378 = *(cast(size_t*)(arg0 + (264+21*size_t.sizeof))); + foreach (_elem377_idx; 0.._listLen378) { + const auto _base377 = _listSrcPtr378 + _elem377_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base377 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base377 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (264+21*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (264+20*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 19: { + break; + } + case 20: { + break; + } + case 21: { + break; + } + case 22: { + break; + } + case 23: { + auto _listSrcPtr385 = *(cast(void**)(arg0 + 40)); + auto _listLen385 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + foreach (_elem384_idx; 0.._listLen385) { + const auto _base384 = _listSrcPtr385 + _elem384_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base384 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base384 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (40+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 40))); + } + break; + } + case 24: { + break; + } + case 25: { + break; + } + case 26: { + break; + } + case 27: { + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (32+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+3*size_t.sizeof)))); + } + auto _listSrcPtr391 = *(cast(void**)(arg0 + (32+5*size_t.sizeof))); + auto _listLen391 = *(cast(size_t*)(arg0 + (32+6*size_t.sizeof))); + foreach (_elem390_idx; 0.._listLen391) { + const auto _base390 = _listSrcPtr391 + _elem390_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base390 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base390 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (32+6*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+5*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (32+8*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+7*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (32+10*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+9*size_t.sizeof)))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (32+11*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (32+13*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+12*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 28: { + break; + } + default: break; + } + break; + } + case 2: { + break; + } + default: break; + } + auto _listSrcPtr397 = *(cast(void**)(arg0 + (368+23*size_t.sizeof))); + auto _listLen397 = *(cast(size_t*)(arg0 + (368+24*size_t.sizeof))); + foreach (_elem396_idx; 0.._listLen397) { + const auto _base396 = _listSrcPtr397 + _elem396_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (368+24*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (368+23*size_t.sizeof)))); + } + break; + } + case 43: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + 16)))) { + case 0: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) { + case 0: { + if (*(cast(size_t*)(arg0 + (48+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 48))); + } + if (*(cast(size_t*)(arg0 + (48+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (48+2*size_t.sizeof)))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (48+5*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (48+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (48+6*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 1: { + break; + } + case 2: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 3: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 4: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 5: { + auto _listSrcPtr409 = *(cast(void**)(arg0 + 32)); + auto _listLen409 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem408_idx; 0.._listLen409) { + const auto _base408 = _listSrcPtr409 + _elem408_idx * (4*size_t.sizeof); + if (*(cast(size_t*)(_base408 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base408 + 0))); + } + if (*(cast(size_t*)(_base408 + (3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base408 + (2*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 6: { + auto _listSrcPtr412 = *(cast(void**)(arg0 + 32)); + auto _listLen412 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem411_idx; 0.._listLen412) { + const auto _base411 = _listSrcPtr412 + _elem411_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base411 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base411 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 7: { + break; + } + case 8: { + auto _listSrcPtr416 = *(cast(void**)(arg0 + 32)); + auto _listLen416 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem415_idx; 0.._listLen416) { + const auto _base415 = _listSrcPtr416 + _elem415_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base415 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base415 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 9: { + break; + } + case 10: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + auto _listSrcPtr420 = *(cast(void**)(arg0 + (32+2*size_t.sizeof))); + auto _listLen420 = *(cast(size_t*)(arg0 + (32+3*size_t.sizeof))); + foreach (_elem419_idx; 0.._listLen420) { + const auto _base419 = _listSrcPtr420 + _elem419_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (32+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+2*size_t.sizeof)))); + } + break; + } + case 11: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + auto _listSrcPtr423 = *(cast(void**)(arg0 + (32+2*size_t.sizeof))); + auto _listLen423 = *(cast(size_t*)(arg0 + (32+3*size_t.sizeof))); + foreach (_elem422_idx; 0.._listLen423) { + const auto _base422 = _listSrcPtr423 + _elem422_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base422 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base422 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (32+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+2*size_t.sizeof)))); + } + break; + } + case 12: { + break; + } + case 13: { + break; + } + case 14: { + auto _listSrcPtr428 = *(cast(void**)(arg0 + 32)); + auto _listLen428 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem427_idx; 0.._listLen428) { + const auto _base427 = _listSrcPtr428 + _elem427_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base427 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base427 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 15: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 16: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + auto _listSrcPtr432 = *(cast(void**)(arg0 + (32+2*size_t.sizeof))); + auto _listLen432 = *(cast(size_t*)(arg0 + (32+3*size_t.sizeof))); + foreach (_elem431_idx; 0.._listLen432) { + const auto _base431 = _listSrcPtr432 + _elem431_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (32+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+2*size_t.sizeof)))); + } + break; + } + case 17: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 18: { + auto _listSrcPtr436 = *(cast(void**)(arg0 + 32)); + auto _listLen436 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem435_idx; 0.._listLen436) { + const auto _base435 = _listSrcPtr436 + _elem435_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base435 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base435 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 19: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 20: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 21: { + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + auto _listSrcPtr441 = *(cast(void**)(arg0 + (32+3*size_t.sizeof))); + auto _listLen441 = *(cast(size_t*)(arg0 + (32+4*size_t.sizeof))); + foreach (_elem440_idx; 0.._listLen441) { + const auto _base440 = _listSrcPtr441 + _elem440_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (32+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+3*size_t.sizeof)))); + } + break; + } + case 22: { + break; + } + case 23: { + break; + } + case 24: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 25: { + if (*(cast(size_t*)(arg0 + (48+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 48))); + } + if (*(cast(size_t*)(arg0 + (48+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (48+2*size_t.sizeof)))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (48+5*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (48+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (48+6*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 26: { + auto _listSrcPtr450 = *(cast(void**)(arg0 + 32)); + auto _listLen450 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem449_idx; 0.._listLen450) { + const auto _base449 = _listSrcPtr450 + _elem449_idx * 12; + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 27: { + break; + } + case 28: { + auto _listSrcPtr454 = *(cast(void**)(arg0 + 48)); + auto _listLen454 = *(cast(size_t*)(arg0 + (48+1*size_t.sizeof))); + foreach (_elem453_idx; 0.._listLen454) { + const auto _base453 = _listSrcPtr454 + _elem453_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (48+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 48))); + } + break; + } + case 29: { + break; + } + case 30: { + break; + } + case 31: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + 48)))) { + case 0: { + if (*(cast(size_t*)(arg0 + (48+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (48+1*size_t.sizeof)))); + } + break; + } + case 1: { + break; + } + case 2: { + break; + } + case 3: { + if (*(cast(size_t*)(arg0 + (48+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (48+1*size_t.sizeof)))); + } + break; + } + case 4: { + break; + } + case 5: { + break; + } + default: break; + } + break; + } + case 32: { + break; + } + case 33: { + break; + } + case 34: { + break; + } + case 35: { + break; + } + case 36: { + break; + } + case 37: { + auto _listSrcPtr473 = *(cast(void**)(arg0 + 32)); + auto _listLen473 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem470_idx; 0.._listLen473) { + const auto _base470 = _listSrcPtr473 + _elem470_idx * (8+2*size_t.sizeof); + auto _listSrcPtr472 = *(cast(void**)(_base470 + 8)); + auto _listLen472 = *(cast(size_t*)(_base470 + (8+1*size_t.sizeof))); + foreach (_elem471_idx; 0.._listLen472) { + const auto _base471 = _listSrcPtr472 + _elem471_idx * 1; + + } + if (*(cast(size_t*)(_base470 + (8+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base470 + 8))); + } + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 38: { + break; + } + case 39: { + break; + } + case 40: { + break; + } + case 41: { + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + case 42: { + break; + } + case 43: { + break; + } + case 44: { + auto _listSrcPtr484 = *(cast(void**)(arg0 + (40+1*size_t.sizeof))); + auto _listLen484 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + foreach (_elem481_idx; 0.._listLen484) { + const auto _base481 = _listSrcPtr484 + _elem481_idx * (5*size_t.sizeof); + if (*(cast(size_t*)(_base481 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base481 + 0))); + } + switch (cast(uint)(*(cast(ubyte*)(_base481 + (2*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(_base481 + (4*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base481 + (3*size_t.sizeof)))); + } + break; + } + default: break; + } + + } + if (*(cast(size_t*)(arg0 + (40+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))); + } + break; + } + case 45: { + auto _listSrcPtr549 = *(cast(void**)(arg0 + 32)); + auto _listLen549 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem486_idx; 0.._listLen549) { + const auto _base486 = _listSrcPtr549 + _elem486_idx * (72+4*size_t.sizeof); + auto _listSrcPtr488 = *(cast(void**)(_base486 + 0)); + auto _listLen488 = *(cast(size_t*)(_base486 + size_t.sizeof)); + foreach (_elem487_idx; 0.._listLen488) { + const auto _base487 = _listSrcPtr488 + _elem487_idx * 4; + + } + if (*(cast(size_t*)(_base486 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base486 + 0))); + } + switch (cast(uint)(*(cast(ubyte*)(_base486 + (2*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(_base486 + (8+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base486 + (8+2*size_t.sizeof)))); + } + break; + } + case 2: { + if (*(cast(size_t*)(_base486 + (8+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base486 + (8+2*size_t.sizeof)))); + } + switch (cast(uint)(*(cast(ubyte*)(_base486 + (24+4*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + break; + } + case 2: { + break; + } + case 3: { + break; + } + case 4: { + break; + } + case 5: { + break; + } + case 6: { + break; + } + case 7: { + break; + } + case 8: { + break; + } + case 9: { + break; + } + case 10: { + break; + } + case 11: { + break; + } + case 12: { + break; + } + case 13: { + break; + } + case 14: { + break; + } + case 15: { + break; + } + case 16: { + break; + } + case 17: { + break; + } + case 18: { + break; + } + case 19: { + break; + } + case 20: { + break; + } + case 21: { + break; + } + case 22: { + break; + } + case 23: { + break; + } + case 24: { + break; + } + case 25: { + break; + } + case 26: { + break; + } + case 27: { + break; + } + case 28: { + break; + } + case 29: { + break; + } + case 30: { + break; + } + case 31: { + break; + } + case 32: { + break; + } + case 33: { + break; + } + case 34: { + break; + } + case 35: { + break; + } + case 36: { + break; + } + case 37: { + break; + } + case 38: { + break; + } + case 39: { + break; + } + case 40: { + break; + } + case 41: { + break; + } + case 42: { + break; + } + case 43: { + break; + } + case 44: { + if (*(cast(size_t*)(_base486 + (32+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base486 + (32+4*size_t.sizeof)))); + } + break; + } + case 45: { + if (*(cast(size_t*)(_base486 + (32+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base486 + (32+4*size_t.sizeof)))); + } + break; + } + case 46: { + if (*(cast(size_t*)(_base486 + (32+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base486 + (32+4*size_t.sizeof)))); + } + break; + } + case 47: { + if (*(cast(size_t*)(_base486 + (32+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base486 + (32+4*size_t.sizeof)))); + } + break; + } + case 48: { + break; + } + case 49: { + break; + } + case 50: { + break; + } + case 51: { + break; + } + case 52: { + break; + } + case 53: { + break; + } + case 54: { + break; + } + case 55: { + break; + } + case 56: { + break; + } + default: break; + } + break; + } + default: break; + } + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 46: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 47: { + auto _listSrcPtr553 = *(cast(void**)(arg0 + (32+1*size_t.sizeof))); + auto _listLen553 = *(cast(size_t*)(arg0 + (32+2*size_t.sizeof))); + foreach (_elem552_idx; 0.._listLen553) { + const auto _base552 = _listSrcPtr553 + _elem552_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base552 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base552 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + case 48: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + auto _listSrcPtr556 = *(cast(void**)(arg0 + (32+2*size_t.sizeof))); + auto _listLen556 = *(cast(size_t*)(arg0 + (32+3*size_t.sizeof))); + foreach (_elem555_idx; 0.._listLen556) { + const auto _base555 = _listSrcPtr556 + _elem555_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (32+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+2*size_t.sizeof)))); + } + break; + } + case 49: { + auto _listSrcPtr559 = *(cast(void**)(arg0 + 32)); + auto _listLen559 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem558_idx; 0.._listLen559) { + const auto _base558 = _listSrcPtr559 + _elem558_idx * (4*size_t.sizeof); + if (*(cast(size_t*)(_base558 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base558 + 0))); + } + if (*(cast(size_t*)(_base558 + (3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base558 + (2*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 50: { + break; + } + case 51: { + if (*(cast(size_t*)(arg0 + (40+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (40+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+3*size_t.sizeof)))); + } + break; + } + case 52: { + if (*(cast(size_t*)(arg0 + (48+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 48))); + } + if (*(cast(size_t*)(arg0 + (48+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (48+2*size_t.sizeof)))); + } + break; + } + case 53: { + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (32+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+3*size_t.sizeof)))); + } + break; + } + case 54: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + auto _listSrcPtr566 = *(cast(void**)(arg0 + (32+2*size_t.sizeof))); + auto _listLen566 = *(cast(size_t*)(arg0 + (32+3*size_t.sizeof))); + foreach (_elem565_idx; 0.._listLen566) { + const auto _base565 = _listSrcPtr566 + _elem565_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (32+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+2*size_t.sizeof)))); + } + break; + } + case 55: { + auto _listSrcPtr569 = *(cast(void**)(arg0 + 32)); + auto _listLen569 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem568_idx; 0.._listLen569) { + const auto _base568 = _listSrcPtr569 + _elem568_idx * 8; + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 56: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + (32+1*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + auto _listSrcPtr574 = *(cast(void**)(arg0 + (32+2*size_t.sizeof))); + auto _listLen574 = *(cast(size_t*)(arg0 + (32+3*size_t.sizeof))); + foreach (_elem573_idx; 0.._listLen574) { + const auto _base573 = _listSrcPtr574 + _elem573_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (32+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+2*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 57: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 58: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + if (*(cast(size_t*)(arg0 + (32+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+3*size_t.sizeof)))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (32+5*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (32+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+6*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 59: { + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + case 60: { + break; + } + case 61: { + auto _listSrcPtr583 = *(cast(void**)(arg0 + (32+1*size_t.sizeof))); + auto _listLen583 = *(cast(size_t*)(arg0 + (32+2*size_t.sizeof))); + foreach (_elem582_idx; 0.._listLen583) { + const auto _base582 = _listSrcPtr583 + _elem582_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + case 62: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 63: { + break; + } + case 64: { + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + case 65: { + if (*(cast(size_t*)(arg0 + (96+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (96+1*size_t.sizeof)))); + } + break; + } + case 66: { + break; + } + case 67: { + auto _listSrcPtr591 = *(cast(void**)(arg0 + 32)); + auto _listLen591 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem590_idx; 0.._listLen591) { + const auto _base590 = _listSrcPtr591 + _elem590_idx * (4*size_t.sizeof); + if (*(cast(size_t*)(_base590 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base590 + 0))); + } + if (*(cast(size_t*)(_base590 + (3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base590 + (2*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 68: { + if (*(cast(size_t*)(arg0 + (48+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 48))); + } + break; + } + case 69: { + break; + } + case 70: { + break; + } + case 71: { + break; + } + case 72: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 73: { + break; + } + case 74: { + break; + } + case 75: { + auto _listSrcPtr601 = *(cast(void**)(arg0 + (40+1*size_t.sizeof))); + auto _listLen601 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + foreach (_elem600_idx; 0.._listLen601) { + const auto _base600 = _listSrcPtr601 + _elem600_idx * 8; + + } + if (*(cast(size_t*)(arg0 + (40+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))); + } + auto _listSrcPtr603 = *(cast(void**)(arg0 + (40+3*size_t.sizeof))); + auto _listLen603 = *(cast(size_t*)(arg0 + (40+4*size_t.sizeof))); + foreach (_elem602_idx; 0.._listLen603) { + const auto _base602 = _listSrcPtr603 + _elem602_idx * 8; + + } + if (*(cast(size_t*)(arg0 + (40+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+3*size_t.sizeof)))); + } + auto _listSrcPtr605 = *(cast(void**)(arg0 + (40+5*size_t.sizeof))); + auto _listLen605 = *(cast(size_t*)(arg0 + (40+6*size_t.sizeof))); + foreach (_elem604_idx; 0.._listLen605) { + const auto _base604 = _listSrcPtr605 + _elem604_idx * 8; + + } + if (*(cast(size_t*)(arg0 + (40+6*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+5*size_t.sizeof)))); + } + auto _listSrcPtr607 = *(cast(void**)(arg0 + (40+7*size_t.sizeof))); + auto _listLen607 = *(cast(size_t*)(arg0 + (40+8*size_t.sizeof))); + foreach (_elem606_idx; 0.._listLen607) { + const auto _base606 = _listSrcPtr607 + _elem606_idx * 8; + + } + if (*(cast(size_t*)(arg0 + (40+8*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+7*size_t.sizeof)))); + } + auto _listSrcPtr611 = *(cast(void**)(arg0 + (40+9*size_t.sizeof))); + auto _listLen611 = *(cast(size_t*)(arg0 + (40+10*size_t.sizeof))); + foreach (_elem608_idx; 0.._listLen611) { + const auto _base608 = _listSrcPtr611 + _elem608_idx * (2*size_t.sizeof); + auto _listSrcPtr610 = *(cast(void**)(_base608 + 0)); + auto _listLen610 = *(cast(size_t*)(_base608 + size_t.sizeof)); + foreach (_elem609_idx; 0.._listLen610) { + const auto _base609 = _listSrcPtr610 + _elem609_idx * 1; + + } + if (*(cast(size_t*)(_base608 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base608 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (40+10*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+9*size_t.sizeof)))); + } + auto _listSrcPtr615 = *(cast(void**)(arg0 + (40+11*size_t.sizeof))); + auto _listLen615 = *(cast(size_t*)(arg0 + (40+12*size_t.sizeof))); + foreach (_elem612_idx; 0.._listLen615) { + const auto _base612 = _listSrcPtr615 + _elem612_idx * (2*size_t.sizeof); + auto _listSrcPtr614 = *(cast(void**)(_base612 + 0)); + auto _listLen614 = *(cast(size_t*)(_base612 + size_t.sizeof)); + foreach (_elem613_idx; 0.._listLen614) { + const auto _base613 = _listSrcPtr614 + _elem613_idx * 1; + + } + if (*(cast(size_t*)(_base612 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base612 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (40+12*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+11*size_t.sizeof)))); + } + break; + } + case 76: { + auto _listSrcPtr618 = *(cast(void**)(arg0 + 40)); + auto _listLen618 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + foreach (_elem617_idx; 0.._listLen618) { + const auto _base617 = _listSrcPtr618 + _elem617_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base617 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base617 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (40+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 40))); + } + if (*(cast(size_t*)(arg0 + (56+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (56+2*size_t.sizeof)))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (64+5*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (64+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (64+6*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 77: { + break; + } + case 78: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + 40)))) { + case 0: { + break; + } + case 1: { + auto _listSrcPtr628 = *(cast(void**)(arg0 + (40+1*size_t.sizeof))); + auto _listLen628 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + foreach (_elem625_idx; 0.._listLen628) { + const auto _base625 = _listSrcPtr628 + _elem625_idx * (8+3*size_t.sizeof); + switch (cast(uint)(*(cast(ubyte*)(_base625 + 8)))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(_base625 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base625 + (8+1*size_t.sizeof)))); + } + break; + } + default: break; + } + + } + if (*(cast(size_t*)(arg0 + (40+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))); + } + break; + } + default: break; + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (40+3*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + auto _listSrcPtr632 = *(cast(void**)(arg0 + (40+5*size_t.sizeof))); + auto _listLen632 = *(cast(size_t*)(arg0 + (40+6*size_t.sizeof))); + foreach (_elem631_idx; 0.._listLen632) { + const auto _base631 = _listSrcPtr632 + _elem631_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (40+6*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+5*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 79: { + auto _listSrcPtr637 = *(cast(void**)(arg0 + (32+1*size_t.sizeof))); + auto _listLen637 = *(cast(size_t*)(arg0 + (32+2*size_t.sizeof))); + foreach (_elem634_idx; 0.._listLen637) { + const auto _base634 = _listSrcPtr637 + _elem634_idx * (24+8*size_t.sizeof); + if (*(cast(size_t*)(_base634 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base634 + 0))); + } + if (*(cast(size_t*)(_base634 + (3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base634 + (2*size_t.sizeof)))); + } + switch (cast(uint)(*(cast(ubyte*)(_base634 + (4*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(_base634 + (6*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base634 + (5*size_t.sizeof)))); + } + break; + } + default: break; + } + + } + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + case 80: { + auto _listSrcPtr640 = *(cast(void**)(arg0 + (32+1*size_t.sizeof))); + auto _listLen640 = *(cast(size_t*)(arg0 + (32+2*size_t.sizeof))); + foreach (_elem639_idx; 0.._listLen640) { + const auto _base639 = _listSrcPtr640 + _elem639_idx * 64; + + } + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + case 81: { + break; + } + case 82: { + auto _listSrcPtr644 = *(cast(void**)(arg0 + (56+1*size_t.sizeof))); + auto _listLen644 = *(cast(size_t*)(arg0 + (56+2*size_t.sizeof))); + foreach (_elem643_idx; 0.._listLen644) { + const auto _base643 = _listSrcPtr644 + _elem643_idx * (8+3*size_t.sizeof); + if (*(cast(size_t*)(_base643 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base643 + (8+1*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(arg0 + (56+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (56+1*size_t.sizeof)))); + } + break; + } + case 83: { + break; + } + case 84: { + break; + } + case 85: { + if (*(cast(size_t*)(arg0 + (40+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 40))); + } + break; + } + case 86: { + break; + } + case 87: { + auto _listSrcPtr651 = *(cast(void**)(arg0 + (96+1*size_t.sizeof))); + auto _listLen651 = *(cast(size_t*)(arg0 + (96+2*size_t.sizeof))); + foreach (_elem650_idx; 0.._listLen651) { + const auto _base650 = _listSrcPtr651 + _elem650_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (96+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (96+1*size_t.sizeof)))); + } + break; + } + case 88: { + break; + } + case 89: { + break; + } + case 90: { + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + case 91: { + break; + } + case 92: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + (56+1*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + auto _listSrcPtr660 = *(cast(void**)(arg0 + (56+2*size_t.sizeof))); + auto _listLen660 = *(cast(size_t*)(arg0 + (56+3*size_t.sizeof))); + foreach (_elem659_idx; 0.._listLen660) { + const auto _base659 = _listSrcPtr660 + _elem659_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (56+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (56+2*size_t.sizeof)))); + } + break; + } + default: break; + } + if (*(cast(size_t*)(arg0 + (56+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (56+4*size_t.sizeof)))); + } + auto _listSrcPtr666 = *(cast(void**)(arg0 + (72+6*size_t.sizeof))); + auto _listLen666 = *(cast(size_t*)(arg0 + (72+7*size_t.sizeof))); + foreach (_elem661_idx; 0.._listLen666) { + const auto _base661 = _listSrcPtr666 + _elem661_idx * (4*size_t.sizeof); + switch (cast(uint)(*(cast(ubyte*)(_base661 + size_t.sizeof)))) { + case 0: { + break; + } + case 1: { + auto _listSrcPtr665 = *(cast(void**)(_base661 + (2*size_t.sizeof))); + auto _listLen665 = *(cast(size_t*)(_base661 + (3*size_t.sizeof))); + foreach (_elem664_idx; 0.._listLen665) { + const auto _base664 = _listSrcPtr665 + _elem664_idx * 1; + + } + if (*(cast(size_t*)(_base661 + (3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base661 + (2*size_t.sizeof)))); + } + break; + } + default: break; + } + + } + if (*(cast(size_t*)(arg0 + (72+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (72+6*size_t.sizeof)))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (72+8*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (72+10*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (72+9*size_t.sizeof)))); + } + break; + } + default: break; + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (72+11*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + break; + } + case 2: { + auto _listSrcPtr673 = *(cast(void**)(arg0 + (72+12*size_t.sizeof))); + auto _listLen673 = *(cast(size_t*)(arg0 + (72+13*size_t.sizeof))); + foreach (_elem672_idx; 0.._listLen673) { + const auto _base672 = _listSrcPtr673 + _elem672_idx * 8; + + } + if (*(cast(size_t*)(arg0 + (72+13*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (72+12*size_t.sizeof)))); + } + break; + } + default: break; + } + if (*(cast(size_t*)(arg0 + (72+16*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (72+15*size_t.sizeof)))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (72+17*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (72+19*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (72+18*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 93: { + auto _listSrcPtr700 = *(cast(void**)(arg0 + (32+1*size_t.sizeof))); + auto _listLen700 = *(cast(size_t*)(arg0 + (32+2*size_t.sizeof))); + foreach (_elem677_idx; 0.._listLen700) { + const auto _base677 = _listSrcPtr700 + _elem677_idx * (16+2*size_t.sizeof); + auto _listSrcPtr699 = *(cast(void**)(_base677 + 16)); + auto _listLen699 = *(cast(size_t*)(_base677 + (16+1*size_t.sizeof))); + foreach (_elem678_idx; 0.._listLen699) { + const auto _base678 = _listSrcPtr699 + _elem678_idx * (40+4*size_t.sizeof); + switch (cast(uint)(*(cast(ubyte*)(_base678 + 0)))) { + case 0: { + if (*(cast(size_t*)(_base678 + (8+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base678 + 8))); + } + auto _listSrcPtr683 = *(cast(void**)(_base678 + (8+2*size_t.sizeof))); + auto _listLen683 = *(cast(size_t*)(_base678 + (8+3*size_t.sizeof))); + foreach (_elem680_idx; 0.._listLen683) { + const auto _base680 = _listSrcPtr683 + _elem680_idx * (16+2*size_t.sizeof); + auto _listSrcPtr682 = *(cast(void**)(_base680 + 16)); + auto _listLen682 = *(cast(size_t*)(_base680 + (16+1*size_t.sizeof))); + foreach (_elem681_idx; 0.._listLen682) { + const auto _base681 = _listSrcPtr682 + _elem681_idx * (16+2*size_t.sizeof); + if (*(cast(size_t*)(_base681 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base681 + 0))); + } + + } + if (*(cast(size_t*)(_base680 + (16+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base680 + 16))); + } + + } + if (*(cast(size_t*)(_base678 + (8+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base678 + (8+2*size_t.sizeof)))); + } + break; + } + case 1: { + switch (cast(uint)(*(cast(ubyte*)(_base678 + 8)))) { + case 0: { + break; + } + case 1: { + auto _listSrcPtr688 = *(cast(void**)(_base678 + 40)); + auto _listLen688 = *(cast(size_t*)(_base678 + (40+1*size_t.sizeof))); + foreach (_elem687_idx; 0.._listLen688) { + const auto _base687 = _listSrcPtr688 + _elem687_idx * 1; + + } + if (*(cast(size_t*)(_base678 + (40+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base678 + 40))); + } + auto _listSrcPtr690 = *(cast(void**)(_base678 + (40+2*size_t.sizeof))); + auto _listLen690 = *(cast(size_t*)(_base678 + (40+3*size_t.sizeof))); + foreach (_elem689_idx; 0.._listLen690) { + const auto _base689 = _listSrcPtr690 + _elem689_idx * 1; + + } + if (*(cast(size_t*)(_base678 + (40+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base678 + (40+2*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 2: { + break; + } + case 3: { + break; + } + case 4: { + break; + } + case 5: { + switch (cast(uint)(*(cast(ubyte*)(_base678 + 8)))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(_base678 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base678 + (8+1*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 6: { + break; + } + case 7: { + break; + } + default: break; + } + + } + if (*(cast(size_t*)(_base677 + (16+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base677 + 16))); + } + + } + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + case 94: { + break; + } + case 95: { + auto _listSrcPtr704 = *(cast(void**)(arg0 + 96)); + auto _listLen704 = *(cast(size_t*)(arg0 + (96+1*size_t.sizeof))); + foreach (_elem703_idx; 0.._listLen704) { + const auto _base703 = _listSrcPtr704 + _elem703_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base703 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base703 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (96+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 96))); + } + break; + } + case 96: { + auto _listSrcPtr707 = *(cast(void**)(arg0 + 32)); + auto _listLen707 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem706_idx; 0.._listLen707) { + const auto _base706 = _listSrcPtr707 + _elem706_idx * 16; + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 97: { + break; + } + case 98: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 99: { + break; + } + case 100: { + break; + } + case 101: { + auto _listSrcPtr714 = *(cast(void**)(arg0 + 32)); + auto _listLen714 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem713_idx; 0.._listLen714) { + const auto _base713 = _listSrcPtr714 + _elem713_idx * 4; + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 102: { + break; + } + case 103: { + auto _listSrcPtr718 = *(cast(void**)(arg0 + 32)); + auto _listLen718 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem717_idx; 0.._listLen718) { + const auto _base717 = _listSrcPtr718 + _elem717_idx * 4; + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 104: { + break; + } + case 105: { + break; + } + case 106: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (32+2*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (32+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+3*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 107: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (40+3*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (40+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+4*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 108: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 109: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (32+2*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (32+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+3*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 110: { + auto _listSrcPtr735 = *(cast(void**)(arg0 + 32)); + auto _listLen735 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem734_idx; 0.._listLen735) { + const auto _base734 = _listSrcPtr735 + _elem734_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base734 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base734 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 111: { + break; + } + case 112: { + break; + } + case 113: { + break; + } + case 114: { + break; + } + case 115: { + break; + } + case 116: { + break; + } + case 117: { + break; + } + case 118: { + auto _listSrcPtr745 = *(cast(void**)(arg0 + 40)); + auto _listLen745 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + foreach (_elem744_idx; 0.._listLen745) { + const auto _base744 = _listSrcPtr745 + _elem744_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base744 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base744 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (40+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 40))); + } + if (*(cast(size_t*)(arg0 + (40+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+2*size_t.sizeof)))); + } + break; + } + case 119: { + break; + } + case 120: { + if (*(cast(size_t*)(arg0 + (40+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))); + } + break; + } + case 121: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 122: { + break; + } + case 123: { + auto _listSrcPtr752 = *(cast(void**)(arg0 + (32+1*size_t.sizeof))); + auto _listLen752 = *(cast(size_t*)(arg0 + (32+2*size_t.sizeof))); + foreach (_elem751_idx; 0.._listLen752) { + const auto _base751 = _listSrcPtr752 + _elem751_idx * (3*size_t.sizeof); + if (*(cast(size_t*)(_base751 + (2*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base751 + size_t.sizeof))); + } + + } + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + case 124: { + break; + } + case 125: { + break; + } + case 126: { + auto _listSrcPtr757 = *(cast(void**)(arg0 + (32+1*size_t.sizeof))); + auto _listLen757 = *(cast(size_t*)(arg0 + (32+2*size_t.sizeof))); + foreach (_elem756_idx; 0.._listLen757) { + const auto _base756 = _listSrcPtr757 + _elem756_idx * 4; + + } + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + case 127: { + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + case 128: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (32+3*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (32+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+4*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (32+8*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+7*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (32+10*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+9*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (32+13*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+12*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (32+15*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+14*size_t.sizeof)))); + } + break; + } + default: break; + } + auto _listSrcPtr763 = *(cast(void**)(arg0 + (32+16*size_t.sizeof))); + auto _listLen763 = *(cast(size_t*)(arg0 + (32+17*size_t.sizeof))); + foreach (_elem762_idx; 0.._listLen763) { + const auto _base762 = _listSrcPtr763 + _elem762_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base762 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base762 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (32+17*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+16*size_t.sizeof)))); + } + break; + } + case 129: { + break; + } + case 130: { + auto _listSrcPtr767 = *(cast(void**)(arg0 + 40)); + auto _listLen767 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + foreach (_elem766_idx; 0.._listLen767) { + const auto _base766 = _listSrcPtr767 + _elem766_idx * 24; + + } + if (*(cast(size_t*)(arg0 + (40+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 40))); + } + break; + } + case 131: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 132: { + break; + } + case 133: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 134: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 135: { + if (*(cast(size_t*)(arg0 + (88+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 88))); + } + break; + } + case 136: { + if (*(cast(size_t*)(arg0 + (88+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (88+1*size_t.sizeof)))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (88+3*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + auto _listSrcPtr777 = *(cast(void**)(arg0 + (88+4*size_t.sizeof))); + auto _listLen777 = *(cast(size_t*)(arg0 + (88+5*size_t.sizeof))); + foreach (_elem776_idx; 0.._listLen777) { + const auto _base776 = _listSrcPtr777 + _elem776_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (88+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (88+4*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 137: { + if (*(cast(size_t*)(arg0 + (56+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 56))); + } + break; + } + case 138: { + break; + } + case 139: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + default: break; + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (32+3*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (32+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+4*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 140: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + auto _listSrcPtr787 = *(cast(void**)(arg0 + (32+2*size_t.sizeof))); + auto _listLen787 = *(cast(size_t*)(arg0 + (32+3*size_t.sizeof))); + foreach (_elem786_idx; 0.._listLen787) { + const auto _base786 = _listSrcPtr787 + _elem786_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (32+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+2*size_t.sizeof)))); + } + break; + } + case 141: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 142: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + if (*(cast(size_t*)(arg0 + (32+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+2*size_t.sizeof)))); + } + break; + } + case 143: { + auto _listSrcPtr792 = *(cast(void**)(arg0 + (32+1*size_t.sizeof))); + auto _listLen792 = *(cast(size_t*)(arg0 + (32+2*size_t.sizeof))); + foreach (_elem791_idx; 0.._listLen792) { + const auto _base791 = _listSrcPtr792 + _elem791_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + case 144: { + break; + } + case 145: { + auto _listSrcPtr796 = *(cast(void**)(arg0 + 96)); + auto _listLen796 = *(cast(size_t*)(arg0 + (96+1*size_t.sizeof))); + foreach (_elem795_idx; 0.._listLen796) { + const auto _base795 = _listSrcPtr796 + _elem795_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base795 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base795 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (96+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 96))); + } + break; + } + case 146: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + 48)))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (48+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (48+1*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 147: { + break; + } + case 148: { + break; + } + case 149: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 150: { + break; + } + case 151: { + auto _listSrcPtr806 = *(cast(void**)(arg0 + (32+1*size_t.sizeof))); + auto _listLen806 = *(cast(size_t*)(arg0 + (32+2*size_t.sizeof))); + foreach (_elem805_idx; 0.._listLen806) { + const auto _base805 = _listSrcPtr806 + _elem805_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base805 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base805 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + auto _listSrcPtr808 = *(cast(void**)(arg0 + (32+3*size_t.sizeof))); + auto _listLen808 = *(cast(size_t*)(arg0 + (32+4*size_t.sizeof))); + foreach (_elem807_idx; 0.._listLen808) { + const auto _base807 = _listSrcPtr808 + _elem807_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base807 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base807 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (32+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+3*size_t.sizeof)))); + } + auto _listSrcPtr810 = *(cast(void**)(arg0 + (32+5*size_t.sizeof))); + auto _listLen810 = *(cast(size_t*)(arg0 + (32+6*size_t.sizeof))); + foreach (_elem809_idx; 0.._listLen810) { + const auto _base809 = _listSrcPtr810 + _elem809_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base809 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base809 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (32+6*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+5*size_t.sizeof)))); + } + break; + } + case 152: { + auto _listSrcPtr815 = *(cast(void**)(arg0 + (32+1*size_t.sizeof))); + auto _listLen815 = *(cast(size_t*)(arg0 + (32+2*size_t.sizeof))); + foreach (_elem812_idx; 0.._listLen815) { + const auto _base812 = _listSrcPtr815 + _elem812_idx * (16+2*size_t.sizeof); + auto _listSrcPtr814 = *(cast(void**)(_base812 + 16)); + auto _listLen814 = *(cast(size_t*)(_base812 + (16+1*size_t.sizeof))); + foreach (_elem813_idx; 0.._listLen814) { + const auto _base813 = _listSrcPtr814 + _elem813_idx * (16+2*size_t.sizeof); + if (*(cast(size_t*)(_base813 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base813 + 0))); + } + + } + if (*(cast(size_t*)(_base812 + (16+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base812 + 16))); + } + + } + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + case 153: { + break; + } + case 154: { + break; + } + case 155: { + break; + } + case 156: { + break; + } + case 157: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + if (*(cast(size_t*)(arg0 + (32+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+3*size_t.sizeof)))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (32+6*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (32+8*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+7*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 158: { + auto _listSrcPtr825 = *(cast(void**)(arg0 + 32)); + auto _listLen825 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem824_idx; 0.._listLen825) { + const auto _base824 = _listSrcPtr825 + _elem824_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 159: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + if (*(cast(size_t*)(arg0 + (32+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+2*size_t.sizeof)))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (32+5*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (32+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+6*size_t.sizeof)))); + } + break; + } + default: break; + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (32+8*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (32+10*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+9*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 160: { + break; + } + case 161: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + 56)))) { + case 0: { + break; + } + case 1: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + (56+1*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (56+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (56+2*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + default: break; + } + break; + } + case 162: { + break; + } + case 163: { + break; + } + case 164: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 165: { + break; + } + default: break; + } + break; + } + case 1: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + 24)))) { + case 0: { + if (*(cast(size_t*)(arg0 + (48+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 48))); + } + auto _listSrcPtr844 = *(cast(void**)(arg0 + (120+2*size_t.sizeof))); + auto _listLen844 = *(cast(size_t*)(arg0 + (120+3*size_t.sizeof))); + foreach (_elem843_idx; 0.._listLen844) { + const auto _base843 = _listSrcPtr844 + _elem843_idx * (8+3*size_t.sizeof); + if (*(cast(size_t*)(_base843 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base843 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (120+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (120+2*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (120+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (120+4*size_t.sizeof)))); + } + auto _listSrcPtr846 = *(cast(void**)(arg0 + (120+6*size_t.sizeof))); + auto _listLen846 = *(cast(size_t*)(arg0 + (120+7*size_t.sizeof))); + foreach (_elem845_idx; 0.._listLen846) { + const auto _base845 = _listSrcPtr846 + _elem845_idx * 8; + + } + if (*(cast(size_t*)(arg0 + (120+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (120+6*size_t.sizeof)))); + } + auto _listSrcPtr848 = *(cast(void**)(arg0 + (120+8*size_t.sizeof))); + auto _listLen848 = *(cast(size_t*)(arg0 + (120+9*size_t.sizeof))); + foreach (_elem847_idx; 0.._listLen848) { + const auto _base847 = _listSrcPtr848 + _elem847_idx * 8; + + } + if (*(cast(size_t*)(arg0 + (120+9*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (120+8*size_t.sizeof)))); + } + auto _listSrcPtr850 = *(cast(void**)(arg0 + (120+10*size_t.sizeof))); + auto _listLen850 = *(cast(size_t*)(arg0 + (120+11*size_t.sizeof))); + foreach (_elem849_idx; 0.._listLen850) { + const auto _base849 = _listSrcPtr850 + _elem849_idx * 24; + + } + if (*(cast(size_t*)(arg0 + (120+11*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (120+10*size_t.sizeof)))); + } + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (64+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 64))); + } + auto _listSrcPtr853 = *(cast(void**)(arg0 + (64+2*size_t.sizeof))); + auto _listLen853 = *(cast(size_t*)(arg0 + (64+3*size_t.sizeof))); + foreach (_elem852_idx; 0.._listLen853) { + const auto _base852 = _listSrcPtr853 + _elem852_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base852 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base852 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (64+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (64+2*size_t.sizeof)))); + } + auto _listSrcPtr855 = *(cast(void**)(arg0 + (64+4*size_t.sizeof))); + auto _listLen855 = *(cast(size_t*)(arg0 + (64+5*size_t.sizeof))); + foreach (_elem854_idx; 0.._listLen855) { + const auto _base854 = _listSrcPtr855 + _elem854_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base854 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base854 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (64+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (64+4*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (128+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (128+6*size_t.sizeof)))); + } + break; + } + case 2: { + if (*(cast(size_t*)(arg0 + (48+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 48))); + } + if (*(cast(size_t*)(arg0 + (56+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (56+2*size_t.sizeof)))); + } + auto _listSrcPtr858 = *(cast(void**)(arg0 + (136+5*size_t.sizeof))); + auto _listLen858 = *(cast(size_t*)(arg0 + (136+6*size_t.sizeof))); + foreach (_elem857_idx; 0.._listLen858) { + const auto _base857 = _listSrcPtr858 + _elem857_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (136+6*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (136+5*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (144+9*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (144+8*size_t.sizeof)))); + } + auto _listSrcPtr860 = *(cast(void**)(arg0 + (144+10*size_t.sizeof))); + auto _listLen860 = *(cast(size_t*)(arg0 + (144+11*size_t.sizeof))); + foreach (_elem859_idx; 0.._listLen860) { + const auto _base859 = _listSrcPtr860 + _elem859_idx * 8; + + } + if (*(cast(size_t*)(arg0 + (144+11*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (144+10*size_t.sizeof)))); + } + auto _listSrcPtr862 = *(cast(void**)(arg0 + (144+12*size_t.sizeof))); + auto _listLen862 = *(cast(size_t*)(arg0 + (144+13*size_t.sizeof))); + foreach (_elem861_idx; 0.._listLen862) { + const auto _base861 = _listSrcPtr862 + _elem861_idx * 8; + + } + if (*(cast(size_t*)(arg0 + (144+13*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (144+12*size_t.sizeof)))); + } + auto _listSrcPtr864 = *(cast(void**)(arg0 + (152+15*size_t.sizeof))); + auto _listLen864 = *(cast(size_t*)(arg0 + (152+16*size_t.sizeof))); + foreach (_elem863_idx; 0.._listLen864) { + const auto _base863 = _listSrcPtr864 + _elem863_idx * 24; + + } + if (*(cast(size_t*)(arg0 + (152+16*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (152+15*size_t.sizeof)))); + } + auto _listSrcPtr866 = *(cast(void**)(arg0 + (160+16*size_t.sizeof))); + auto _listLen866 = *(cast(size_t*)(arg0 + (160+17*size_t.sizeof))); + foreach (_elem865_idx; 0.._listLen866) { + const auto _base865 = _listSrcPtr866 + _elem865_idx * 24; + + } + if (*(cast(size_t*)(arg0 + (160+17*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (160+16*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (160+19*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (160+18*size_t.sizeof)))); + } + break; + } + case 3: { + auto _listSrcPtr869 = *(cast(void**)(arg0 + 32)); + auto _listLen869 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem868_idx; 0.._listLen869) { + const auto _base868 = _listSrcPtr869 + _elem868_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base868 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base868 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + auto _listSrcPtr871 = *(cast(void**)(arg0 + (32+2*size_t.sizeof))); + auto _listLen871 = *(cast(size_t*)(arg0 + (32+3*size_t.sizeof))); + foreach (_elem870_idx; 0.._listLen871) { + const auto _base870 = _listSrcPtr871 + _elem870_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base870 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base870 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (32+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+2*size_t.sizeof)))); + } + auto _listSrcPtr873 = *(cast(void**)(arg0 + (32+4*size_t.sizeof))); + auto _listLen873 = *(cast(size_t*)(arg0 + (32+5*size_t.sizeof))); + foreach (_elem872_idx; 0.._listLen873) { + const auto _base872 = _listSrcPtr873 + _elem872_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base872 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base872 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (32+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+4*size_t.sizeof)))); + } + auto _listSrcPtr877 = *(cast(void**)(arg0 + (32+6*size_t.sizeof))); + auto _listLen877 = *(cast(size_t*)(arg0 + (32+7*size_t.sizeof))); + foreach (_elem874_idx; 0.._listLen877) { + const auto _base874 = _listSrcPtr877 + _elem874_idx * (4*size_t.sizeof); + if (*(cast(size_t*)(_base874 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base874 + 0))); + } + auto _listSrcPtr876 = *(cast(void**)(_base874 + (2*size_t.sizeof))); + auto _listLen876 = *(cast(size_t*)(_base874 + (3*size_t.sizeof))); + foreach (_elem875_idx; 0.._listLen876) { + const auto _base875 = _listSrcPtr876 + _elem875_idx * 4; + + } + if (*(cast(size_t*)(_base874 + (3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base874 + (2*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(arg0 + (32+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+6*size_t.sizeof)))); + } + auto _listSrcPtr881 = *(cast(void**)(arg0 + (32+8*size_t.sizeof))); + auto _listLen881 = *(cast(size_t*)(arg0 + (32+9*size_t.sizeof))); + foreach (_elem878_idx; 0.._listLen881) { + const auto _base878 = _listSrcPtr881 + _elem878_idx * (4*size_t.sizeof); + if (*(cast(size_t*)(_base878 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base878 + 0))); + } + auto _listSrcPtr880 = *(cast(void**)(_base878 + (2*size_t.sizeof))); + auto _listLen880 = *(cast(size_t*)(_base878 + (3*size_t.sizeof))); + foreach (_elem879_idx; 0.._listLen880) { + const auto _base879 = _listSrcPtr880 + _elem879_idx * 8; + + } + if (*(cast(size_t*)(_base878 + (3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base878 + (2*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(arg0 + (32+9*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+8*size_t.sizeof)))); + } + auto _listSrcPtr889 = *(cast(void**)(arg0 + (32+10*size_t.sizeof))); + auto _listLen889 = *(cast(size_t*)(arg0 + (32+11*size_t.sizeof))); + foreach (_elem882_idx; 0.._listLen889) { + const auto _base882 = _listSrcPtr889 + _elem882_idx * (8+9*size_t.sizeof); + if (*(cast(size_t*)(_base882 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base882 + 0))); + } + if (*(cast(size_t*)(_base882 + (3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base882 + (2*size_t.sizeof)))); + } + auto _listSrcPtr884 = *(cast(void**)(_base882 + (8+5*size_t.sizeof))); + auto _listLen884 = *(cast(size_t*)(_base882 + (8+6*size_t.sizeof))); + foreach (_elem883_idx; 0.._listLen884) { + const auto _base883 = _listSrcPtr884 + _elem883_idx * 4; + + } + if (*(cast(size_t*)(_base882 + (8+6*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base882 + (8+5*size_t.sizeof)))); + } + auto _listSrcPtr888 = *(cast(void**)(_base882 + (8+7*size_t.sizeof))); + auto _listLen888 = *(cast(size_t*)(_base882 + (8+8*size_t.sizeof))); + foreach (_elem885_idx; 0.._listLen888) { + const auto _base885 = _listSrcPtr888 + _elem885_idx * (3*size_t.sizeof); + auto _listSrcPtr887 = *(cast(void**)(_base885 + size_t.sizeof)); + auto _listLen887 = *(cast(size_t*)(_base885 + (2*size_t.sizeof))); + foreach (_elem886_idx; 0.._listLen887) { + const auto _base886 = _listSrcPtr887 + _elem886_idx * (8+2*size_t.sizeof); + if (*(cast(size_t*)(_base886 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base886 + 0))); + } + + } + if (*(cast(size_t*)(_base885 + (2*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base885 + size_t.sizeof))); + } + + } + if (*(cast(size_t*)(_base882 + (8+8*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base882 + (8+7*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(arg0 + (32+11*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+10*size_t.sizeof)))); + } + auto _listSrcPtr893 = *(cast(void**)(arg0 + (32+12*size_t.sizeof))); + auto _listLen893 = *(cast(size_t*)(arg0 + (32+13*size_t.sizeof))); + foreach (_elem890_idx; 0.._listLen893) { + const auto _base890 = _listSrcPtr893 + _elem890_idx * (4*size_t.sizeof); + if (*(cast(size_t*)(_base890 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base890 + 0))); + } + auto _listSrcPtr892 = *(cast(void**)(_base890 + (2*size_t.sizeof))); + auto _listLen892 = *(cast(size_t*)(_base890 + (3*size_t.sizeof))); + foreach (_elem891_idx; 0.._listLen892) { + const auto _base891 = _listSrcPtr892 + _elem891_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base891 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base891 + 0))); + } + + } + if (*(cast(size_t*)(_base890 + (3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base890 + (2*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(arg0 + (32+13*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+12*size_t.sizeof)))); + } + auto _listSrcPtr897 = *(cast(void**)(arg0 + (32+14*size_t.sizeof))); + auto _listLen897 = *(cast(size_t*)(arg0 + (32+15*size_t.sizeof))); + foreach (_elem894_idx; 0.._listLen897) { + const auto _base894 = _listSrcPtr897 + _elem894_idx * (8+2*size_t.sizeof); + auto _listSrcPtr896 = *(cast(void**)(_base894 + 8)); + auto _listLen896 = *(cast(size_t*)(_base894 + (8+1*size_t.sizeof))); + foreach (_elem895_idx; 0.._listLen896) { + const auto _base895 = _listSrcPtr896 + _elem895_idx * 1; + + } + if (*(cast(size_t*)(_base894 + (8+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base894 + 8))); + } + + } + if (*(cast(size_t*)(arg0 + (32+15*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+14*size_t.sizeof)))); + } + break; + } + case 4: { + break; + } + case 5: { + if (*(cast(size_t*)(arg0 + (40+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))); + } + break; + } + case 6: { + break; + } + case 7: { + if (*(cast(size_t*)(arg0 + (48+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (48+1*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (48+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (48+3*size_t.sizeof)))); + } + break; + } + case 8: { + break; + } + case 9: { + break; + } + case 10: { + auto _listSrcPtr908 = *(cast(void**)(arg0 + 32)); + auto _listLen908 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem905_idx; 0.._listLen908) { + const auto _base905 = _listSrcPtr908 + _elem905_idx * (8+2*size_t.sizeof); + auto _listSrcPtr907 = *(cast(void**)(_base905 + 8)); + auto _listLen907 = *(cast(size_t*)(_base905 + (8+1*size_t.sizeof))); + foreach (_elem906_idx; 0.._listLen907) { + const auto _base906 = _listSrcPtr907 + _elem906_idx * 1; + + } + if (*(cast(size_t*)(_base905 + (8+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base905 + 8))); + } + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 11: { + break; + } + case 12: { + break; + } + case 13: { + auto _listSrcPtr931 = *(cast(void**)(arg0 + 32)); + auto _listLen931 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem912_idx; 0.._listLen931) { + const auto _base912 = _listSrcPtr931 + _elem912_idx * (48+8*size_t.sizeof); + switch (cast(uint)(*(cast(ubyte*)(_base912 + 0)))) { + case 0: { + if (*(cast(size_t*)(_base912 + (8+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base912 + 8))); + } + auto _listSrcPtr915 = *(cast(void**)(_base912 + (8+2*size_t.sizeof))); + auto _listLen915 = *(cast(size_t*)(_base912 + (8+3*size_t.sizeof))); + foreach (_elem914_idx; 0.._listLen915) { + const auto _base914 = _listSrcPtr915 + _elem914_idx * (8+2*size_t.sizeof); + if (*(cast(size_t*)(_base914 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base914 + 0))); + } + + } + if (*(cast(size_t*)(_base912 + (8+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base912 + (8+2*size_t.sizeof)))); + } + auto _listSrcPtr921 = *(cast(void**)(_base912 + (8+4*size_t.sizeof))); + auto _listLen921 = *(cast(size_t*)(_base912 + (8+5*size_t.sizeof))); + foreach (_elem916_idx; 0.._listLen921) { + const auto _base916 = _listSrcPtr921 + _elem916_idx * (24+6*size_t.sizeof); + if (*(cast(size_t*)(_base916 + (16+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base916 + 16))); + } + auto _listSrcPtr918 = *(cast(void**)(_base916 + (16+2*size_t.sizeof))); + auto _listLen918 = *(cast(size_t*)(_base916 + (16+3*size_t.sizeof))); + foreach (_elem917_idx; 0.._listLen918) { + const auto _base917 = _listSrcPtr918 + _elem917_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base917 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base917 + 0))); + } + + } + if (*(cast(size_t*)(_base916 + (16+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base916 + (16+2*size_t.sizeof)))); + } + auto _listSrcPtr920 = *(cast(void**)(_base916 + (16+4*size_t.sizeof))); + auto _listLen920 = *(cast(size_t*)(_base916 + (16+5*size_t.sizeof))); + foreach (_elem919_idx; 0.._listLen920) { + const auto _base919 = _listSrcPtr920 + _elem919_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base919 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base919 + 0))); + } + + } + if (*(cast(size_t*)(_base916 + (16+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base916 + (16+4*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(_base912 + (8+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base912 + (8+4*size_t.sizeof)))); + } + if (*(cast(size_t*)(_base912 + (24+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base912 + (24+6*size_t.sizeof)))); + } + break; + } + case 1: { + if (*(cast(size_t*)(_base912 + (8+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base912 + 8))); + } + auto _listSrcPtr924 = *(cast(void**)(_base912 + (16+2*size_t.sizeof))); + auto _listLen924 = *(cast(size_t*)(_base912 + (16+3*size_t.sizeof))); + foreach (_elem923_idx; 0.._listLen924) { + const auto _base923 = _listSrcPtr924 + _elem923_idx * (8+2*size_t.sizeof); + if (*(cast(size_t*)(_base923 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base923 + 0))); + } + + } + if (*(cast(size_t*)(_base912 + (16+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base912 + (16+2*size_t.sizeof)))); + } + auto _listSrcPtr930 = *(cast(void**)(_base912 + (16+4*size_t.sizeof))); + auto _listLen930 = *(cast(size_t*)(_base912 + (16+5*size_t.sizeof))); + foreach (_elem925_idx; 0.._listLen930) { + const auto _base925 = _listSrcPtr930 + _elem925_idx * (24+6*size_t.sizeof); + if (*(cast(size_t*)(_base925 + (16+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base925 + 16))); + } + auto _listSrcPtr927 = *(cast(void**)(_base925 + (16+2*size_t.sizeof))); + auto _listLen927 = *(cast(size_t*)(_base925 + (16+3*size_t.sizeof))); + foreach (_elem926_idx; 0.._listLen927) { + const auto _base926 = _listSrcPtr927 + _elem926_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base926 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base926 + 0))); + } + + } + if (*(cast(size_t*)(_base925 + (16+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base925 + (16+2*size_t.sizeof)))); + } + auto _listSrcPtr929 = *(cast(void**)(_base925 + (16+4*size_t.sizeof))); + auto _listLen929 = *(cast(size_t*)(_base925 + (16+5*size_t.sizeof))); + foreach (_elem928_idx; 0.._listLen929) { + const auto _base928 = _listSrcPtr929 + _elem928_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base928 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base928 + 0))); + } + + } + if (*(cast(size_t*)(_base925 + (16+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base925 + (16+4*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(_base912 + (16+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base912 + (16+4*size_t.sizeof)))); + } + if (*(cast(size_t*)(_base912 + (32+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base912 + (32+6*size_t.sizeof)))); + } + break; + } + default: break; + } + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 14: { + auto _listSrcPtr938 = *(cast(void**)(arg0 + 32)); + auto _listLen938 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem933_idx; 0.._listLen938) { + const auto _base933 = _listSrcPtr938 + _elem933_idx * (32+8*size_t.sizeof); + if (*(cast(size_t*)(_base933 + (2*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base933 + size_t.sizeof))); + } + if (*(cast(size_t*)(_base933 + (24+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base933 + (24+2*size_t.sizeof)))); + } + auto _listSrcPtr935 = *(cast(void**)(_base933 + (24+4*size_t.sizeof))); + auto _listLen935 = *(cast(size_t*)(_base933 + (24+5*size_t.sizeof))); + foreach (_elem934_idx; 0.._listLen935) { + const auto _base934 = _listSrcPtr935 + _elem934_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base934 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base934 + 0))); + } + + } + if (*(cast(size_t*)(_base933 + (24+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base933 + (24+4*size_t.sizeof)))); + } + auto _listSrcPtr937 = *(cast(void**)(_base933 + (24+6*size_t.sizeof))); + auto _listLen937 = *(cast(size_t*)(_base933 + (24+7*size_t.sizeof))); + foreach (_elem936_idx; 0.._listLen937) { + const auto _base936 = _listSrcPtr937 + _elem936_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base936 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base936 + 0))); + } + + } + if (*(cast(size_t*)(_base933 + (24+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base933 + (24+6*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + auto _listSrcPtr944 = *(cast(void**)(arg0 + (32+2*size_t.sizeof))); + auto _listLen944 = *(cast(size_t*)(arg0 + (32+3*size_t.sizeof))); + foreach (_elem939_idx; 0.._listLen944) { + const auto _base939 = _listSrcPtr944 + _elem939_idx * (40+6*size_t.sizeof); + if (*(cast(size_t*)(_base939 + (24+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base939 + 24))); + } + auto _listSrcPtr941 = *(cast(void**)(_base939 + (24+2*size_t.sizeof))); + auto _listLen941 = *(cast(size_t*)(_base939 + (24+3*size_t.sizeof))); + foreach (_elem940_idx; 0.._listLen941) { + const auto _base940 = _listSrcPtr941 + _elem940_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base940 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base940 + 0))); + } + + } + if (*(cast(size_t*)(_base939 + (24+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base939 + (24+2*size_t.sizeof)))); + } + auto _listSrcPtr943 = *(cast(void**)(_base939 + (24+4*size_t.sizeof))); + auto _listLen943 = *(cast(size_t*)(_base939 + (24+5*size_t.sizeof))); + foreach (_elem942_idx; 0.._listLen943) { + const auto _base942 = _listSrcPtr943 + _elem942_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base942 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base942 + 0))); + } + + } + if (*(cast(size_t*)(_base939 + (24+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base939 + (24+4*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(arg0 + (32+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+2*size_t.sizeof)))); + } + break; + } + case 15: { + if (*(cast(size_t*)(arg0 + (40+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 40))); + } + if (*(cast(size_t*)(arg0 + (40+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+2*size_t.sizeof)))); + } + break; + } + case 16: { + auto _listSrcPtr948 = *(cast(void**)(arg0 + 32)); + auto _listLen948 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem947_idx; 0.._listLen948) { + const auto _base947 = _listSrcPtr948 + _elem947_idx * (3*size_t.sizeof); + if (*(cast(size_t*)(_base947 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base947 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 17: { + auto _listSrcPtr953 = *(cast(void**)(arg0 + (32+1*size_t.sizeof))); + auto _listLen953 = *(cast(size_t*)(arg0 + (32+2*size_t.sizeof))); + foreach (_elem950_idx; 0.._listLen953) { + const auto _base950 = _listSrcPtr953 + _elem950_idx * (24+2*size_t.sizeof); + auto _listSrcPtr952 = *(cast(void**)(_base950 + 16)); + auto _listLen952 = *(cast(size_t*)(_base950 + (16+1*size_t.sizeof))); + foreach (_elem951_idx; 0.._listLen952) { + const auto _base951 = _listSrcPtr952 + _elem951_idx * 1; + + } + if (*(cast(size_t*)(_base950 + (16+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base950 + 16))); + } + + } + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + auto _listSrcPtr955 = *(cast(void**)(arg0 + (56+4*size_t.sizeof))); + auto _listLen955 = *(cast(size_t*)(arg0 + (56+5*size_t.sizeof))); + foreach (_elem954_idx; 0.._listLen955) { + const auto _base954 = _listSrcPtr955 + _elem954_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (56+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (56+4*size_t.sizeof)))); + } + break; + } + case 18: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + 56)))) { + case 0: { + break; + } + case 1: { + auto _listSrcPtr960 = *(cast(void**)(arg0 + (72+1*size_t.sizeof))); + auto _listLen960 = *(cast(size_t*)(arg0 + (72+2*size_t.sizeof))); + foreach (_elem959_idx; 0.._listLen960) { + const auto _base959 = _listSrcPtr960 + _elem959_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (72+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (72+1*size_t.sizeof)))); + } + break; + } + default: break; + } + auto _listSrcPtr962 = *(cast(void**)(arg0 + (96+3*size_t.sizeof))); + auto _listLen962 = *(cast(size_t*)(arg0 + (96+4*size_t.sizeof))); + foreach (_elem961_idx; 0.._listLen962) { + const auto _base961 = _listSrcPtr962 + _elem961_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (96+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (96+3*size_t.sizeof)))); + } + break; + } + case 19: { + auto _listSrcPtr967 = *(cast(void**)(arg0 + 32)); + auto _listLen967 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem964_idx; 0.._listLen967) { + const auto _base964 = _listSrcPtr967 + _elem964_idx * (8+5*size_t.sizeof); + if (*(cast(size_t*)(_base964 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base964 + 0))); + } + auto _listSrcPtr966 = *(cast(void**)(_base964 + (8+3*size_t.sizeof))); + auto _listLen966 = *(cast(size_t*)(_base964 + (8+4*size_t.sizeof))); + foreach (_elem965_idx; 0.._listLen966) { + const auto _base965 = _listSrcPtr966 + _elem965_idx * 1; + + } + if (*(cast(size_t*)(_base964 + (8+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base964 + (8+3*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 20: { + auto _listSrcPtr974 = *(cast(void**)(arg0 + 32)); + auto _listLen974 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem969_idx; 0.._listLen974) { + const auto _base969 = _listSrcPtr974 + _elem969_idx * (8+2*size_t.sizeof); + auto _listSrcPtr973 = *(cast(void**)(_base969 + 8)); + auto _listLen973 = *(cast(size_t*)(_base969 + (8+1*size_t.sizeof))); + foreach (_elem970_idx; 0.._listLen973) { + const auto _base970 = _listSrcPtr973 + _elem970_idx * (8+3*size_t.sizeof); + auto _listSrcPtr972 = *(cast(void**)(_base970 + (8+1*size_t.sizeof))); + auto _listLen972 = *(cast(size_t*)(_base970 + (8+2*size_t.sizeof))); + foreach (_elem971_idx; 0.._listLen972) { + const auto _base971 = _listSrcPtr972 + _elem971_idx * (8+5*size_t.sizeof); + if (*(cast(size_t*)(_base971 + (8+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base971 + 8))); + } + if (*(cast(size_t*)(_base971 + (8+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base971 + (8+2*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(_base970 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base970 + (8+1*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(_base969 + (8+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base969 + 8))); + } + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 21: { + auto _listSrcPtr977 = *(cast(void**)(arg0 + 40)); + auto _listLen977 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + foreach (_elem976_idx; 0.._listLen977) { + const auto _base976 = _listSrcPtr977 + _elem976_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (40+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 40))); + } + auto _listSrcPtr979 = *(cast(void**)(arg0 + (40+2*size_t.sizeof))); + auto _listLen979 = *(cast(size_t*)(arg0 + (40+3*size_t.sizeof))); + foreach (_elem978_idx; 0.._listLen979) { + const auto _base978 = _listSrcPtr979 + _elem978_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base978 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base978 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (40+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+2*size_t.sizeof)))); + } + break; + } + case 22: { + break; + } + case 23: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + if (*(cast(size_t*)(arg0 + (56+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (56+3*size_t.sizeof)))); + } + break; + } + case 24: { + break; + } + case 25: { + auto _listSrcPtr985 = *(cast(void**)(arg0 + 56)); + auto _listLen985 = *(cast(size_t*)(arg0 + (56+1*size_t.sizeof))); + foreach (_elem984_idx; 0.._listLen985) { + const auto _base984 = _listSrcPtr985 + _elem984_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (56+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 56))); + } + break; + } + case 26: { + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + case 27: { + break; + } + case 28: { + break; + } + case 29: { + break; + } + case 30: { + auto _listSrcPtr992 = *(cast(void**)(arg0 + 48)); + auto _listLen992 = *(cast(size_t*)(arg0 + (48+1*size_t.sizeof))); + foreach (_elem991_idx; 0.._listLen992) { + const auto _base991 = _listSrcPtr992 + _elem991_idx * 16; + + } + if (*(cast(size_t*)(arg0 + (48+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 48))); + } + break; + } + case 31: { + break; + } + case 32: { + break; + } + case 33: { + break; + } + case 34: { + auto _listSrcPtr1020 = *(cast(void**)(arg0 + (32+1*size_t.sizeof))); + auto _listLen1020 = *(cast(size_t*)(arg0 + (32+2*size_t.sizeof))); + foreach (_elem997_idx; 0.._listLen1020) { + const auto _base997 = _listSrcPtr1020 + _elem997_idx * (48+42*size_t.sizeof); + if (*(cast(size_t*)(_base997 + (24+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base997 + 24))); + } + if (*(cast(size_t*)(_base997 + (24+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base997 + (24+2*size_t.sizeof)))); + } + if (*(cast(size_t*)(_base997 + (24+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base997 + (24+4*size_t.sizeof)))); + } + if (*(cast(size_t*)(_base997 + (24+8*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base997 + (24+7*size_t.sizeof)))); + } + if (*(cast(size_t*)(_base997 + (24+10*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base997 + (24+9*size_t.sizeof)))); + } + auto _listSrcPtr999 = *(cast(void**)(_base997 + (24+11*size_t.sizeof))); + auto _listLen999 = *(cast(size_t*)(_base997 + (24+12*size_t.sizeof))); + foreach (_elem998_idx; 0.._listLen999) { + const auto _base998 = _listSrcPtr999 + _elem998_idx * 1; + + } + if (*(cast(size_t*)(_base997 + (24+12*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base997 + (24+11*size_t.sizeof)))); + } + auto _listSrcPtr1001 = *(cast(void**)(_base997 + (32+13*size_t.sizeof))); + auto _listLen1001 = *(cast(size_t*)(_base997 + (32+14*size_t.sizeof))); + foreach (_elem1000_idx; 0.._listLen1001) { + const auto _base1000 = _listSrcPtr1001 + _elem1000_idx * 1; + + } + if (*(cast(size_t*)(_base997 + (32+14*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base997 + (32+13*size_t.sizeof)))); + } + auto _listSrcPtr1003 = *(cast(void**)(_base997 + (32+15*size_t.sizeof))); + auto _listLen1003 = *(cast(size_t*)(_base997 + (32+16*size_t.sizeof))); + foreach (_elem1002_idx; 0.._listLen1003) { + const auto _base1002 = _listSrcPtr1003 + _elem1002_idx * (24+2*size_t.sizeof); + if (*(cast(size_t*)(_base1002 + (8+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base1002 + 8))); + } + + } + if (*(cast(size_t*)(_base997 + (32+16*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base997 + (32+15*size_t.sizeof)))); + } + auto _listSrcPtr1005 = *(cast(void**)(_base997 + (40+17*size_t.sizeof))); + auto _listLen1005 = *(cast(size_t*)(_base997 + (40+18*size_t.sizeof))); + foreach (_elem1004_idx; 0.._listLen1005) { + const auto _base1004 = _listSrcPtr1005 + _elem1004_idx * 1; + + } + if (*(cast(size_t*)(_base997 + (40+18*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base997 + (40+17*size_t.sizeof)))); + } + auto _listSrcPtr1007 = *(cast(void**)(_base997 + (40+19*size_t.sizeof))); + auto _listLen1007 = *(cast(size_t*)(_base997 + (40+20*size_t.sizeof))); + foreach (_elem1006_idx; 0.._listLen1007) { + const auto _base1006 = _listSrcPtr1007 + _elem1006_idx * 1; + + } + if (*(cast(size_t*)(_base997 + (40+20*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base997 + (40+19*size_t.sizeof)))); + } + auto _listSrcPtr1009 = *(cast(void**)(_base997 + (40+21*size_t.sizeof))); + auto _listLen1009 = *(cast(size_t*)(_base997 + (40+22*size_t.sizeof))); + foreach (_elem1008_idx; 0.._listLen1009) { + const auto _base1008 = _listSrcPtr1009 + _elem1008_idx * 1; + + } + if (*(cast(size_t*)(_base997 + (40+22*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base997 + (40+21*size_t.sizeof)))); + } + auto _listSrcPtr1011 = *(cast(void**)(_base997 + (40+23*size_t.sizeof))); + auto _listLen1011 = *(cast(size_t*)(_base997 + (40+24*size_t.sizeof))); + foreach (_elem1010_idx; 0.._listLen1011) { + const auto _base1010 = _listSrcPtr1011 + _elem1010_idx * 1; + + } + if (*(cast(size_t*)(_base997 + (40+24*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base997 + (40+23*size_t.sizeof)))); + } + if (*(cast(size_t*)(_base997 + (40+26*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base997 + (40+25*size_t.sizeof)))); + } + if (*(cast(size_t*)(_base997 + (40+28*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base997 + (40+27*size_t.sizeof)))); + } + if (*(cast(size_t*)(_base997 + (40+30*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base997 + (40+29*size_t.sizeof)))); + } + if (*(cast(size_t*)(_base997 + (40+32*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base997 + (40+31*size_t.sizeof)))); + } + auto _listSrcPtr1013 = *(cast(void**)(_base997 + (40+33*size_t.sizeof))); + auto _listLen1013 = *(cast(size_t*)(_base997 + (40+34*size_t.sizeof))); + foreach (_elem1012_idx; 0.._listLen1013) { + const auto _base1012 = _listSrcPtr1013 + _elem1012_idx * (9*size_t.sizeof); + if (*(cast(size_t*)(_base1012 + (2*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base1012 + size_t.sizeof))); + } + if (*(cast(size_t*)(_base1012 + (4*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base1012 + (3*size_t.sizeof)))); + } + if (*(cast(size_t*)(_base1012 + (6*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base1012 + (5*size_t.sizeof)))); + } + if (*(cast(size_t*)(_base1012 + (8*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base1012 + (7*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(_base997 + (40+34*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base997 + (40+33*size_t.sizeof)))); + } + auto _listSrcPtr1017 = *(cast(void**)(_base997 + (40+35*size_t.sizeof))); + auto _listLen1017 = *(cast(size_t*)(_base997 + (40+36*size_t.sizeof))); + foreach (_elem1014_idx; 0.._listLen1017) { + const auto _base1014 = _listSrcPtr1017 + _elem1014_idx * (4*size_t.sizeof); + if (*(cast(size_t*)(_base1014 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base1014 + 0))); + } + auto _listSrcPtr1016 = *(cast(void**)(_base1014 + (2*size_t.sizeof))); + auto _listLen1016 = *(cast(size_t*)(_base1014 + (3*size_t.sizeof))); + foreach (_elem1015_idx; 0.._listLen1016) { + const auto _base1015 = _listSrcPtr1016 + _elem1015_idx * 4; + + } + if (*(cast(size_t*)(_base1014 + (3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base1014 + (2*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(_base997 + (40+36*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base997 + (40+35*size_t.sizeof)))); + } + if (*(cast(size_t*)(_base997 + (48+38*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base997 + (48+37*size_t.sizeof)))); + } + auto _listSrcPtr1019 = *(cast(void**)(_base997 + (48+40*size_t.sizeof))); + auto _listLen1019 = *(cast(size_t*)(_base997 + (48+41*size_t.sizeof))); + foreach (_elem1018_idx; 0.._listLen1019) { + const auto _base1018 = _listSrcPtr1019 + _elem1018_idx * 1; + + } + if (*(cast(size_t*)(_base997 + (48+41*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base997 + (48+40*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + case 35: { + break; + } + case 36: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 37: { + auto _listSrcPtr1025 = *(cast(void**)(arg0 + (32+1*size_t.sizeof))); + auto _listLen1025 = *(cast(size_t*)(arg0 + (32+2*size_t.sizeof))); + foreach (_elem1024_idx; 0.._listLen1025) { + const auto _base1024 = _listSrcPtr1025 + _elem1024_idx * (6*size_t.sizeof); + if (*(cast(size_t*)(_base1024 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base1024 + 0))); + } + if (*(cast(size_t*)(_base1024 + (3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base1024 + (2*size_t.sizeof)))); + } + if (*(cast(size_t*)(_base1024 + (5*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base1024 + (4*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (32+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+3*size_t.sizeof)))); + } + auto _listSrcPtr1027 = *(cast(void**)(arg0 + (32+5*size_t.sizeof))); + auto _listLen1027 = *(cast(size_t*)(arg0 + (32+6*size_t.sizeof))); + foreach (_elem1026_idx; 0.._listLen1027) { + const auto _base1026 = _listSrcPtr1027 + _elem1026_idx * (3*size_t.sizeof); + if (*(cast(size_t*)(_base1026 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base1026 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (32+6*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+5*size_t.sizeof)))); + } + break; + } + case 38: { + if (*(cast(size_t*)(arg0 + (56+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 56))); + } + auto _listSrcPtr1030 = *(cast(void**)(arg0 + (56+2*size_t.sizeof))); + auto _listLen1030 = *(cast(size_t*)(arg0 + (56+3*size_t.sizeof))); + foreach (_elem1029_idx; 0.._listLen1030) { + const auto _base1029 = _listSrcPtr1030 + _elem1029_idx * (32+10*size_t.sizeof); + if (*(cast(size_t*)(_base1029 + (16+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base1029 + 16))); + } + if (*(cast(size_t*)(_base1029 + (24+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base1029 + (24+2*size_t.sizeof)))); + } + if (*(cast(size_t*)(_base1029 + (24+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base1029 + (24+4*size_t.sizeof)))); + } + if (*(cast(size_t*)(_base1029 + (24+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base1029 + (24+6*size_t.sizeof)))); + } + if (*(cast(size_t*)(_base1029 + (24+10*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base1029 + (24+9*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(arg0 + (56+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (56+2*size_t.sizeof)))); + } + break; + } + case 39: { + if (*(cast(size_t*)(arg0 + (40+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 40))); + } + auto _listSrcPtr1033 = *(cast(void**)(arg0 + (40+2*size_t.sizeof))); + auto _listLen1033 = *(cast(size_t*)(arg0 + (40+3*size_t.sizeof))); + foreach (_elem1032_idx; 0.._listLen1033) { + const auto _base1032 = _listSrcPtr1033 + _elem1032_idx * 8; + + } + if (*(cast(size_t*)(arg0 + (40+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+2*size_t.sizeof)))); + } + auto _listSrcPtr1035 = *(cast(void**)(arg0 + (40+4*size_t.sizeof))); + auto _listLen1035 = *(cast(size_t*)(arg0 + (40+5*size_t.sizeof))); + foreach (_elem1034_idx; 0.._listLen1035) { + const auto _base1034 = _listSrcPtr1035 + _elem1034_idx * 8; + + } + if (*(cast(size_t*)(arg0 + (40+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+4*size_t.sizeof)))); + } + break; + } + case 40: { + break; + } + case 41: { + break; + } + case 42: { + break; + } + case 43: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + if (*(cast(size_t*)(arg0 + (32+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+2*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (32+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+4*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (32+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+6*size_t.sizeof)))); + } + break; + } + case 44: { + break; + } + case 45: { + break; + } + case 46: { + auto _listSrcPtr1044 = *(cast(void**)(arg0 + (32+1*size_t.sizeof))); + auto _listLen1044 = *(cast(size_t*)(arg0 + (32+2*size_t.sizeof))); + foreach (_elem1043_idx; 0.._listLen1044) { + const auto _base1043 = _listSrcPtr1044 + _elem1043_idx * (24+4*size_t.sizeof); + if (*(cast(size_t*)(_base1043 + (8+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base1043 + 8))); + } + if (*(cast(size_t*)(_base1043 + (24+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base1043 + (24+2*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + case 47: { + break; + } + case 48: { + break; + } + case 49: { + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (40+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+4*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (40+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+6*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (40+9*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+8*size_t.sizeof)))); + } + break; + } + case 50: { + break; + } + case 51: { + if (*(cast(size_t*)(arg0 + (96+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (96+1*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (144+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (144+4*size_t.sizeof)))); + } + auto _listSrcPtr1051 = *(cast(void**)(arg0 + (160+6*size_t.sizeof))); + auto _listLen1051 = *(cast(size_t*)(arg0 + (160+7*size_t.sizeof))); + foreach (_elem1050_idx; 0.._listLen1051) { + const auto _base1050 = _listSrcPtr1051 + _elem1050_idx * (3*size_t.sizeof); + if (*(cast(size_t*)(_base1050 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base1050 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (160+7*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (160+6*size_t.sizeof)))); + } + auto _listSrcPtr1053 = *(cast(void**)(arg0 + (160+8*size_t.sizeof))); + auto _listLen1053 = *(cast(size_t*)(arg0 + (160+9*size_t.sizeof))); + foreach (_elem1052_idx; 0.._listLen1053) { + const auto _base1052 = _listSrcPtr1053 + _elem1052_idx * (3*size_t.sizeof); + if (*(cast(size_t*)(_base1052 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base1052 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (160+9*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (160+8*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (176+13*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (176+12*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (184+16*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (184+15*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (184+18*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (184+17*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (192+21*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (192+20*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (192+23*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (192+22*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (192+25*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (192+24*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (224+27*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (224+26*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (224+30*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (224+29*size_t.sizeof)))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (264+32*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + (272+32*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (296+33*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (296+32*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (312+35*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (312+34*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (312+37*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (312+36*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (344+39*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (344+38*size_t.sizeof)))); + } + break; + } + default: break; + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (344+40*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (344+42*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (344+41*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (344+44*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (344+43*size_t.sizeof)))); + } + break; + } + default: break; + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (344+45*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (344+47*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (344+46*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (344+49*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (344+48*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + default: break; + } + if (*(cast(size_t*)(arg0 + (344+51*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (344+50*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (344+53*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (344+52*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (344+55*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (344+54*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (344+57*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (344+56*size_t.sizeof)))); + } + break; + } + case 52: { + break; + } + case 53: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 54: { + auto _listSrcPtr1066 = *(cast(void**)(arg0 + (40+1*size_t.sizeof))); + auto _listLen1066 = *(cast(size_t*)(arg0 + (40+2*size_t.sizeof))); + foreach (_elem1065_idx; 0.._listLen1066) { + const auto _base1065 = _listSrcPtr1066 + _elem1065_idx * 24; + + } + if (*(cast(size_t*)(arg0 + (40+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+1*size_t.sizeof)))); + } + break; + } + case 55: { + auto _listSrcPtr1071 = *(cast(void**)(arg0 + 40)); + auto _listLen1071 = *(cast(size_t*)(arg0 + (40+1*size_t.sizeof))); + foreach (_elem1068_idx; 0.._listLen1071) { + const auto _base1068 = _listSrcPtr1071 + _elem1068_idx * (24+4*size_t.sizeof); + if (*(cast(size_t*)(_base1068 + (24+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base1068 + 24))); + } + auto _listSrcPtr1070 = *(cast(void**)(_base1068 + (24+2*size_t.sizeof))); + auto _listLen1070 = *(cast(size_t*)(_base1068 + (24+3*size_t.sizeof))); + foreach (_elem1069_idx; 0.._listLen1070) { + const auto _base1069 = _listSrcPtr1070 + _elem1069_idx * (16+4*size_t.sizeof); + if (*(cast(size_t*)(_base1069 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base1069 + 0))); + } + if (*(cast(size_t*)(_base1069 + (3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base1069 + (2*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(_base1068 + (24+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(_base1068 + (24+2*size_t.sizeof)))); + } + + } + if (*(cast(size_t*)(arg0 + (40+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 40))); + } + break; + } + case 56: { + break; + } + case 57: { + if (*(cast(size_t*)(arg0 + (64+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 64))); + } + if (*(cast(size_t*)(arg0 + (64+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (64+3*size_t.sizeof)))); + } + break; + } + case 58: { + break; + } + default: break; + } + break; + } + case 2: { + break; + } + default: break; + } + auto _listSrcPtr1077 = *(cast(void**)(arg0 + (344+59*size_t.sizeof))); + auto _listLen1077 = *(cast(size_t*)(arg0 + (344+60*size_t.sizeof))); + foreach (_elem1076_idx; 0.._listLen1077) { + const auto _base1076 = _listSrcPtr1077 + _elem1076_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (344+60*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (344+59*size_t.sizeof)))); + } + break; + } + case 44: { + break; + } + case 45: { + break; + } + case 46: { + break; + } + case 47: { + break; + } + case 48: { + break; + } + case 49: { + break; + } + case 50: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 51: { + break; + } + case 52: { + break; + } + case 53: { + break; + } + case 54: { + break; + } + case 55: { + break; + } + case 56: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 57: { + break; + } + case 58: { + break; + } + case 59: { + break; + } + case 60: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 61: { + break; + } + case 62: { + break; + } + case 63: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 64: { + break; + } + case 65: { + break; + } + case 66: { + break; + } + case 67: { + break; + } + case 68: { + if (*(cast(size_t*)(arg0 + (16+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 16))); + } + break; + } + case 69: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 70: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 71: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 72: { + break; + } + case 73: { + break; + } + case 74: { + if (*(cast(size_t*)(arg0 + (24+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 24))); + } + break; + } + case 75: { + if (*(cast(size_t*)(arg0 + (24+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 24))); + } + break; + } + case 76: { + break; + } + case 77: { + break; + } + case 78: { + break; + } + case 79: { + break; + } + case 80: { + break; + } + case 81: { + if (*(cast(size_t*)(arg0 + (16+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))); + } + break; + } + case 82: { + break; + } + case 83: { + break; + } + case 84: { + if (*(cast(size_t*)(arg0 + (16+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))); + } + break; + } + case 85: { + if (*(cast(size_t*)(arg0 + (16+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))); + } + break; + } + case 86: { + if (*(cast(size_t*)(arg0 + (16+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))); + } + break; + } + case 87: { + auto _listSrcPtr1123 = *(cast(void**)(arg0 + 24)); + auto _listLen1123 = *(cast(size_t*)(arg0 + (24+1*size_t.sizeof))); + foreach (_elem1122_idx; 0.._listLen1123) { + const auto _base1122 = _listSrcPtr1123 + _elem1122_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base1122 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base1122 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (24+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 24))); + } + break; + } + case 88: { + break; + } + case 89: { + if (*(cast(size_t*)(arg0 + (16+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))); + } + break; + } + case 90: { + break; + } + case 91: { + break; + } + case 92: { + break; + } + case 93: { + break; + } + case 94: { + if (*(cast(size_t*)(arg0 + (8+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 8))); + } + if (*(cast(size_t*)(arg0 + (8+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+2*size_t.sizeof)))); + } + break; + } + case 95: { + if (*(cast(size_t*)(arg0 + (8+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 8))); + } + if (*(cast(size_t*)(arg0 + (8+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+2*size_t.sizeof)))); + } + break; + } + case 96: { + break; + } + case 97: { + break; + } + case 98: { + break; + } + case 99: { + break; + } + case 100: { + if (*(cast(size_t*)(arg0 + (8+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 8))); + } + break; + } + case 101: { + if (*(cast(size_t*)(arg0 + (8+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 8))); + } + break; + } + case 102: { + if (*(cast(size_t*)(arg0 + (16+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))); + } + break; + } + case 103: { + if (*(cast(size_t*)(arg0 + (16+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))); + } + break; + } + case 104: { + break; + } + case 105: { + break; + } + case 106: { + if (*(cast(size_t*)(arg0 + (8+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 8))); + } + break; + } + case 107: { + break; + } + case 108: { + break; + } + case 109: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 110: { + if (*(cast(size_t*)(arg0 + (16+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (16+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (16+3*size_t.sizeof)))); + } + break; + } + case 111: { + break; + } + case 112: { + break; + } + case 113: { + if (*(cast(size_t*)(arg0 + (16+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))); + } + break; + } + case 114: { + if (*(cast(size_t*)(arg0 + (24+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 24))); + } + break; + } + case 115: { + if (*(cast(size_t*)(arg0 + (16+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))); + } + break; + } + case 116: { + break; + } + case 117: { + if (*(cast(size_t*)(arg0 + (16+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 16))); + } + break; + } + case 118: { + break; + } + case 119: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 120: { + if (*(cast(size_t*)(arg0 + (24+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 24))); + } + break; + } + case 121: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 122: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + (8+1*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (8+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+2*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 123: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + (8+1*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (8+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+2*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 124: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 125: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + (8+1*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (8+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+2*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 126: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 127: { + break; + } + case 128: { + break; + } + case 129: { + break; + } + case 130: { + break; + } + case 131: { + break; + } + case 132: { + break; + } + case 133: { + break; + } + case 134: { + break; + } + case 135: { + break; + } + case 136: { + break; + } + case 137: { + break; + } + case 138: { + auto _listSrcPtr1182 = *(cast(void**)(arg0 + 16)); + auto _listLen1182 = *(cast(size_t*)(arg0 + (16+1*size_t.sizeof))); + foreach (_elem1181_idx; 0.._listLen1182) { + const auto _base1181 = _listSrcPtr1182 + _elem1181_idx * 12; + + } + if (*(cast(size_t*)(arg0 + (16+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 16))); + } + break; + } + case 139: { + auto _listSrcPtr1185 = *(cast(void**)(arg0 + 24)); + auto _listLen1185 = *(cast(size_t*)(arg0 + (24+1*size_t.sizeof))); + foreach (_elem1184_idx; 0.._listLen1185) { + const auto _base1184 = _listSrcPtr1185 + _elem1184_idx * 8; + + } + if (*(cast(size_t*)(arg0 + (24+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 24))); + } + break; + } + case 140: { + break; + } + case 141: { + break; + } + case 142: { + break; + } + case 143: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 144: { + break; + } + case 145: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + 32)))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (32+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (32+1*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 146: { + break; + } + case 147: { + break; + } + case 148: { + break; + } + case 149: { + break; + } + case 150: { + auto _listSrcPtr1200 = *(cast(void**)(arg0 + 24)); + auto _listLen1200 = *(cast(size_t*)(arg0 + (24+1*size_t.sizeof))); + foreach (_elem1199_idx; 0.._listLen1200) { + const auto _base1199 = _listSrcPtr1200 + _elem1199_idx * 4; + + } + if (*(cast(size_t*)(arg0 + (24+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 24))); + } + break; + } + case 151: { + auto _listSrcPtr1203 = *(cast(void**)(arg0 + 32)); + auto _listLen1203 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem1202_idx; 0.._listLen1203) { + const auto _base1202 = _listSrcPtr1203 + _elem1202_idx * 4; + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 152: { + break; + } + case 153: { + auto _listSrcPtr1207 = *(cast(void**)(arg0 + 32)); + auto _listLen1207 = *(cast(size_t*)(arg0 + (32+1*size_t.sizeof))); + foreach (_elem1206_idx; 0.._listLen1207) { + const auto _base1206 = _listSrcPtr1207 + _elem1206_idx * 16; + + } + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 154: { + auto _listSrcPtr1210 = *(cast(void**)(arg0 + 16)); + auto _listLen1210 = *(cast(size_t*)(arg0 + (16+1*size_t.sizeof))); + foreach (_elem1209_idx; 0.._listLen1210) { + const auto _base1209 = _listSrcPtr1210 + _elem1209_idx * 16; + + } + if (*(cast(size_t*)(arg0 + (16+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 16))); + } + break; + } + case 155: { + if (*(cast(size_t*)(arg0 + (24+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 24))); + } + break; + } + case 156: { + break; + } + case 157: { + break; + } + case 158: { + break; + } + case 159: { + break; + } + case 160: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 161: { + break; + } + case 162: { + break; + } + case 163: { + break; + } + case 164: { + break; + } + case 165: { + break; + } + case 166: { + break; + } + case 167: { + break; + } + case 168: { + break; + } + case 169: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (40+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (40+3*size_t.sizeof)))); + } + break; + } + case 170: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (8+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+3*size_t.sizeof)))); + } + break; + } + case 171: { + break; + } + case 172: { + if (*(cast(size_t*)(arg0 + (24+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 24))); + } + break; + } + case 173: { + if (*(cast(size_t*)(arg0 + (32+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 32))); + } + break; + } + case 174: { + if (*(cast(size_t*)(arg0 + (16+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))); + } + break; + } + case 175: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 176: { + break; + } + case 177: { + break; + } + case 178: { + break; + } + case 179: { + break; + } + case 180: { + if (*(cast(size_t*)(arg0 + (24+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 24))); + } + break; + } + case 181: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 182: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 183: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 184: { + if (*(cast(size_t*)(arg0 + (16+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))); + } + break; + } + case 185: { + break; + } + case 186: { + break; + } + case 187: { + break; + } + case 188: { + break; + } + case 189: { + break; + } + case 190: { + break; + } + case 191: { + if (*(cast(size_t*)(arg0 + (40+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 40))); + } + break; + } + case 192: { + auto _listSrcPtr1250 = *(cast(void**)(arg0 + 16)); + auto _listLen1250 = *(cast(size_t*)(arg0 + (16+1*size_t.sizeof))); + foreach (_elem1249_idx; 0.._listLen1250) { + const auto _base1249 = _listSrcPtr1250 + _elem1249_idx * 4; + + } + if (*(cast(size_t*)(arg0 + (16+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 16))); + } + break; + } + case 193: { + break; + } + case 194: { + break; + } + case 195: { + break; + } + case 196: { + break; + } + case 197: { + break; + } + case 198: { + break; + } + case 199: { + break; + } + case 200: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (8+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+3*size_t.sizeof)))); + } + break; + } + case 201: { + break; + } + case 202: { + break; + } + case 203: { + auto _listSrcPtr1263 = *(cast(void**)(arg0 + (8+1*size_t.sizeof))); + auto _listLen1263 = *(cast(size_t*)(arg0 + (8+2*size_t.sizeof))); + foreach (_elem1262_idx; 0.._listLen1263) { + const auto _base1262 = _listSrcPtr1263 + _elem1262_idx * 4; + + } + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 204: { + break; + } + case 205: { + break; + } + case 206: { + if (*(cast(size_t*)(arg0 + (16+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (16+1*size_t.sizeof)))); + } + break; + } + case 207: { + break; + } + case 208: { + break; + } + case 209: { + break; + } + case 210: { + break; + } + case 211: { + break; + } + case 212: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 213: { + break; + } + case 214: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 215: { + break; + } + case 216: { + break; + } + case 217: { + if (*(cast(size_t*)(arg0 + (24+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 24))); + } + break; + } + case 218: { + break; + } + case 219: { + break; + } + case 220: { + if (*(cast(size_t*)(arg0 + (24+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 24))); + } + auto _listSrcPtr1282 = *(cast(void**)(arg0 + (24+2*size_t.sizeof))); + auto _listLen1282 = *(cast(size_t*)(arg0 + (24+3*size_t.sizeof))); + foreach (_elem1281_idx; 0.._listLen1282) { + const auto _base1281 = _listSrcPtr1282 + _elem1281_idx * 4; + + } + if (*(cast(size_t*)(arg0 + (24+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (24+2*size_t.sizeof)))); + } + break; + } + case 221: { + break; + } + case 222: { + break; + } + case 223: { + break; + } + case 224: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 225: { + if (*(cast(size_t*)(arg0 + (8+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 8))); + } + if (*(cast(size_t*)(arg0 + (8+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+2*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (8+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+4*size_t.sizeof)))); + } + break; + } + case 226: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 227: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 228: { + break; + } + case 229: { + if (*(cast(size_t*)(arg0 + (16+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 16))); + } + break; + } + case 230: { + break; + } + case 231: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 232: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 233: { + auto _listSrcPtr1297 = *(cast(void**)(arg0 + 16)); + auto _listLen1297 = *(cast(size_t*)(arg0 + (16+1*size_t.sizeof))); + foreach (_elem1296_idx; 0.._listLen1297) { + const auto _base1296 = _listSrcPtr1297 + _elem1296_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base1296 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base1296 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (16+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 16))); + } + switch (cast(uint)(*(cast(ubyte*)(arg0 + (16+2*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (16+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (16+3*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 234: { + break; + } + case 235: { + break; + } + case 236: { + auto _listSrcPtr1304 = *(cast(void**)(arg0 + 24)); + auto _listLen1304 = *(cast(size_t*)(arg0 + (24+1*size_t.sizeof))); + foreach (_elem1303_idx; 0.._listLen1304) { + const auto _base1303 = _listSrcPtr1304 + _elem1303_idx * 4; + + } + if (*(cast(size_t*)(arg0 + (24+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 24))); + } + break; + } + case 237: { + break; + } + case 238: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 239: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 240: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 241: { + break; + } + case 242: { + break; + } + case 243: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 244: { + break; + } + case 245: { + break; + } + case 246: { + break; + } + case 247: { + if (*(cast(size_t*)(arg0 + (8+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 8))); + } + if (*(cast(size_t*)(arg0 + (8+3*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+2*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (8+5*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+4*size_t.sizeof)))); + } + break; + } + case 248: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 249: { + break; + } + case 250: { + break; + } + case 251: { + break; + } + case 252: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 253: { + break; + } + case 254: { + break; + } + case 255: { + break; + } + case 256: { + break; + } + case 257: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 258: { + break; + } + case 259: { + auto _listSrcPtr1329 = *(cast(void**)(arg0 + (8+1*size_t.sizeof))); + auto _listLen1329 = *(cast(size_t*)(arg0 + (8+2*size_t.sizeof))); + foreach (_elem1328_idx; 0.._listLen1329) { + const auto _base1328 = _listSrcPtr1329 + _elem1328_idx * (2*size_t.sizeof); + if (*(cast(size_t*)(_base1328 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base1328 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 260: { + break; + } + case 261: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 262: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 263: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 264: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 265: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + if (*(cast(size_t*)(arg0 + (8+4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+3*size_t.sizeof)))); + } + break; + } + case 266: { + break; + } + case 267: { + if (*(cast(size_t*)(arg0 + (8+2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (8+1*size_t.sizeof)))); + } + break; + } + case 268: { + break; + } + case 269: { + break; + } + case 270: { + if (*(cast(size_t*)(arg0 + (8+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 8))); + } + break; + } + case 271: { + break; + } + case 272: { + break; + } + default: break; + } + } + + /++ + Dispatches a command execution to the plugin. + +/ + alias handleCommand_Sig = Result!(int, CommandError) function(uint commandId, CommandSender sender, ServerInstance server, ConsumedArgs args); + /// ditto + alias handleCommand_Impl = findWitExportFunc!("$root", "handle-command", handleCommand_Sig, Impl); + /// ditto + @wasmExport!("handle-command") + pragma(mangle, "__wit_export_handle_command") + private extern(C) void* __export_handleCommand(uint arg0, uint arg1, uint arg2, uint arg3) { + alias _retArea = _exportsRetArea; + auto _handle0 = CommandSender(arg1); + auto _handle1 = ServerInstance(arg2); + auto _handle2 = ConsumedArgs(arg3); + auto _ret = handleCommand_Impl(arg0, _handle0, _handle1, _handle2); + if (_ret.isErr) { + ref _payload6 = _ret.unwrapErr(); + *cast(ubyte*)(_retArea.ptr + 0) = cast(ubyte)(1); + alias _Tag19 = wit.pumpkin.plugin.command.imports.CommandError.Tag; + final switch (_payload6.tag) { + case _Tag19.invalidConsumption: { + ref Option!(WitString) _payload8 = _payload6.getInvalidConsumption(); + *cast(ubyte*)(_retArea.ptr + size_t.sizeof) = cast(ubyte)(0); + if (_payload8.isSome) { + ref _payload12 = _payload8.unwrap(); + *cast(ubyte*)(_retArea.ptr + (2*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (4*size_t.sizeof)) = cast(size_t)(_payload12.length); + *cast(void**)(_retArea.ptr + (3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload12.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (2*size_t.sizeof)) = cast(ubyte)(0); + } + break; + } + case _Tag19.invalidRequirement: { + *cast(ubyte*)(_retArea.ptr + size_t.sizeof) = cast(ubyte)(1); + break; + } + case _Tag19.permissionDenied: { + *cast(ubyte*)(_retArea.ptr + size_t.sizeof) = cast(ubyte)(2); + break; + } + case _Tag19.commandFailed: { + ref wit.pumpkin.plugin.command.imports.TextComponent _payload18 = _payload6.getCommandFailed(); + *cast(ubyte*)(_retArea.ptr + size_t.sizeof) = cast(ubyte)(3); + *cast(uint*)(_retArea.ptr + (2*size_t.sizeof)) = cast(uint)(_payload18.__handle); + break; + } + } + } else { + ref _payload4 = _ret.unwrap(); + *cast(ubyte*)(_retArea.ptr + 0) = cast(ubyte)(0); + *cast(uint*)(_retArea.ptr + size_t.sizeof) = cast(uint)(cast(uint)(_payload4)); + } + return _retArea.ptr; + } + @wasmExport!("cabi_post_handle-command") + pragma(mangle, "__wit_cabi_post_handle_command") + private extern(C) void __cabi_post_handleCommand(void* arg0) { + switch (cast(uint)(*(cast(ubyte*)(arg0 + 0)))) { + case 0: { + break; + } + case 1: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + size_t.sizeof)))) { + case 0: { + switch (cast(uint)(*(cast(ubyte*)(arg0 + (2*size_t.sizeof))))) { + case 0: { + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (4*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + (3*size_t.sizeof)))); + } + break; + } + default: break; + } + break; + } + case 1: { + break; + } + case 2: { + break; + } + case 3: { + break; + } + default: break; + } + break; + } + default: break; + } + } + + /++ + Dispatches a command suggestion request to the plugin. + +/ + alias handleCommandSuggestion_Sig = CommandSuggestions function(uint handlerId, CommandSender sender, ServerInstance server, in SuggestionRequest request); + /// ditto + alias handleCommandSuggestion_Impl = findWitExportFunc!("$root", "handle-command-suggestion", handleCommandSuggestion_Sig, Impl); + /// ditto + @wasmExport!("handle-command-suggestion") + pragma(mangle, "__wit_export_handle_command_suggestion") + private extern(C) void* __export_handleCommandSuggestion(uint arg0, uint arg1, uint arg2, void* arg3, size_t arg4, uint arg5, uint arg6, void* arg7, size_t arg8) { + alias _retArea = _exportsRetArea; + wit.common.DeallocateBuffer deallocate; + auto _handle0 = CommandSender(arg1); + auto _handle1 = ServerInstance(arg2); + auto _len2 = arg4; + auto _ptr2 = _len2 ? cast(char*)(arg3) : null; + if (_len2) deallocate ~= cast()_ptr2; + auto _list3 = WitString(_ptr2[0.._len2]); + auto _len4 = arg8; + auto _ptr4 = _len4 ? cast(char*)(arg7) : null; + if (_len4) deallocate ~= cast()_ptr4; + auto _list5 = WitString(_ptr4[0.._len4]); + wit.pumpkin.plugin.command.common.SuggestionRequest _record6 = { + input: _list3, + cursor: arg5, + start: arg6, + remaining: _list5, + }; + auto _ret = handleCommandSuggestion_Impl(arg0, _handle0, _handle1, _record6); + deallocate.purge(); + *cast(uint*)(_retArea.ptr + 0) = cast(uint)(_ret.start); + *cast(uint*)(_retArea.ptr + 4) = cast(uint)(_ret.length); + auto _listSrc12 = _ret.values; + auto _list12 = _listSrc12.length ? wit.common.malloc(_listSrc12.length * ((8+2*size_t.sizeof))) : null; + assert(!_listSrc12.length || _list12); + foreach (_elem7_idx, ref _elem7; _listSrc12) { + auto _base7 = _list12 + _elem7_idx * ((8+2*size_t.sizeof)); + *cast(size_t*)(_base7 + size_t.sizeof) = cast(size_t)(_elem7.value.length); + *cast(void**)(_base7 + 0) = cast(void*)(cast(void*)(_elem7.value.ptr)); + if (_elem7.tooltip.isSome) { + ref _payload11 = _elem7.tooltip.unwrap(); + *cast(ubyte*)(_base7 + (2*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_base7 + (4+2*size_t.sizeof)) = cast(uint)(_payload11.__handle); + } else { + *cast(ubyte*)(_base7 + (2*size_t.sizeof)) = cast(ubyte)(0); + } + + } + if (_listSrc12.length) wit.common.free(_listSrc12.ptr); + *cast(size_t*)(_retArea.ptr + (8+1*size_t.sizeof)) = cast(size_t)(_ret.values.length); + *cast(void**)(_retArea.ptr + 8) = cast(void*)(_list12); + return _retArea.ptr; + } + @wasmExport!("cabi_post_handle-command-suggestion") + pragma(mangle, "__wit_cabi_post_handle_command_suggestion") + private extern(C) void __cabi_post_handleCommandSuggestion(void* arg0) { + auto _listSrcPtr1 = *(cast(void**)(arg0 + 8)); + auto _listLen1 = *(cast(size_t*)(arg0 + (8+1*size_t.sizeof))); + foreach (_elem0_idx; 0.._listLen1) { + const auto _base0 = _listSrcPtr1 + _elem0_idx * (8+2*size_t.sizeof); + if (*(cast(size_t*)(_base0 + size_t.sizeof)) > 0) { + free(*(cast(void**)(_base0 + 0))); + } + + } + if (*(cast(size_t*)(arg0 + (8+1*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + 8))); + } + } + + /++ + Dispatches a scheduled task execution to the plugin. + +/ + alias handleTask_Sig = void function(uint handlerId, ServerInstance server); + /// ditto + alias handleTask_Impl = findWitExportFunc!("$root", "handle-task", handleTask_Sig, Impl); + /// ditto + @wasmExport!("handle-task") + pragma(mangle, "__wit_export_handle_task") + private extern(C) void __export_handleTask(uint arg0, uint arg1) { + auto _handle0 = ServerInstance(arg1); + handleTask_Impl(arg0, _handle0); + } + + /++ + Processes an incoming message from another plugin if possible, and returns (a possibly empty) response. + +/ + alias handleIpcMessage_Sig = Result!(IpcMessage, WitString) function(in PluginId sender, in IpcMessage message); + /// ditto + alias handleIpcMessage_Impl = findWitExportFunc!("$root", "handle-ipc-message", handleIpcMessage_Sig, Impl); + /// ditto + @wasmExport!("handle-ipc-message") + pragma(mangle, "__wit_export_handle_ipc_message") + private extern(C) void* __export_handleIpcMessage(void* arg0, size_t arg1, void* arg2, size_t arg3) { + alias _retArea = _exportsRetArea; + wit.common.DeallocateBuffer deallocate; + auto _len0 = arg1; + auto _ptr0 = _len0 ? cast(char*)(arg0) : null; + if (_len0) deallocate ~= cast()_ptr0; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _len2 = arg3; + auto _ptr2 = _len2 ? cast(ubyte*)(arg2) : null; + if (_len2) deallocate ~= cast()_ptr2; + auto _list3 = wit.pumpkin.plugin.ipc.common.IpcMessage(_ptr2[0.._len2]); + auto _ret = handleIpcMessage_Impl(_list1, _list3); + deallocate.purge(); + if (_ret.isErr) { + ref _payload7 = _ret.unwrapErr(); + *cast(ubyte*)(_retArea.ptr + 0) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (2*size_t.sizeof)) = cast(size_t)(_payload7.length); + *cast(void**)(_retArea.ptr + size_t.sizeof) = cast(void*)(cast(void*)(_payload7.ptr)); + } else { + ref _payload5 = _ret.unwrap(); + *cast(ubyte*)(_retArea.ptr + 0) = cast(ubyte)(0); + *cast(size_t*)(_retArea.ptr + (2*size_t.sizeof)) = cast(size_t)(_payload5.length); + *cast(void**)(_retArea.ptr + size_t.sizeof) = cast(void*)(cast(void*)(_payload5.ptr)); + } + return _retArea.ptr; + } + @wasmExport!("cabi_post_handle-ipc-message") + pragma(mangle, "__wit_cabi_post_handle_ipc_message") + private extern(C) void __cabi_post_handleIpcMessage(void* arg0) { + switch (cast(uint)(*(cast(ubyte*)(arg0 + 0)))) { + case 0: { + auto _listSrcPtr2 = *(cast(void**)(arg0 + size_t.sizeof)); + auto _listLen2 = *(cast(size_t*)(arg0 + (2*size_t.sizeof))); + foreach (_elem1_idx; 0.._listLen2) { + const auto _base1 = _listSrcPtr2 + _elem1_idx * 1; + + } + if (*(cast(size_t*)(arg0 + (2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + size_t.sizeof))); + } + break; + } + case 1: { + if (*(cast(size_t*)(arg0 + (2*size_t.sizeof))) > 0) { + free(*(cast(void**)(arg0 + size_t.sizeof))); + } + break; + } + default: break; + } + } + + /++ + + +/ + alias handleAiGoalCanStart_Sig = bool function(uint goalId, ServerInstance server, Entity entity); + /// ditto + alias handleAiGoalCanStart_Impl = findWitExportFunc!("$root", "handle-ai-goal-can-start", handleAiGoalCanStart_Sig, Impl); + /// ditto + @wasmExport!("handle-ai-goal-can-start") + pragma(mangle, "__wit_export_handle_ai_goal_can_start") + private extern(C) uint __export_handleAiGoalCanStart(uint arg0, uint arg1, uint arg2) { + auto _handle0 = ServerInstance(arg1); + auto _handle1 = Entity(arg2); + auto _ret = handleAiGoalCanStart_Impl(arg0, _handle0, _handle1); + return cast(uint)(_ret); + } + + /++ + + +/ + alias handleAiGoalShouldContinue_Sig = bool function(uint goalId, ServerInstance server, Entity entity); + /// ditto + alias handleAiGoalShouldContinue_Impl = findWitExportFunc!("$root", "handle-ai-goal-should-continue", handleAiGoalShouldContinue_Sig, Impl); + /// ditto + @wasmExport!("handle-ai-goal-should-continue") + pragma(mangle, "__wit_export_handle_ai_goal_should_continue") + private extern(C) uint __export_handleAiGoalShouldContinue(uint arg0, uint arg1, uint arg2) { + auto _handle0 = ServerInstance(arg1); + auto _handle1 = Entity(arg2); + auto _ret = handleAiGoalShouldContinue_Impl(arg0, _handle0, _handle1); + return cast(uint)(_ret); + } + + /++ + + +/ + alias handleAiGoalStart_Sig = void function(uint goalId, ServerInstance server, Entity entity); + /// ditto + alias handleAiGoalStart_Impl = findWitExportFunc!("$root", "handle-ai-goal-start", handleAiGoalStart_Sig, Impl); + /// ditto + @wasmExport!("handle-ai-goal-start") + pragma(mangle, "__wit_export_handle_ai_goal_start") + private extern(C) void __export_handleAiGoalStart(uint arg0, uint arg1, uint arg2) { + auto _handle0 = ServerInstance(arg1); + auto _handle1 = Entity(arg2); + handleAiGoalStart_Impl(arg0, _handle0, _handle1); + } + + /++ + + +/ + alias handleAiGoalTick_Sig = void function(uint goalId, ServerInstance server, Entity entity); + /// ditto + alias handleAiGoalTick_Impl = findWitExportFunc!("$root", "handle-ai-goal-tick", handleAiGoalTick_Sig, Impl); + /// ditto + @wasmExport!("handle-ai-goal-tick") + pragma(mangle, "__wit_export_handle_ai_goal_tick") + private extern(C) void __export_handleAiGoalTick(uint arg0, uint arg1, uint arg2) { + auto _handle0 = ServerInstance(arg1); + auto _handle1 = Entity(arg2); + handleAiGoalTick_Impl(arg0, _handle0, _handle1); + } + + /++ + + +/ + alias handleAiGoalStop_Sig = void function(uint goalId, ServerInstance server, Entity entity); + /// ditto + alias handleAiGoalStop_Impl = findWitExportFunc!("$root", "handle-ai-goal-stop", handleAiGoalStop_Sig, Impl); + /// ditto + @wasmExport!("handle-ai-goal-stop") + pragma(mangle, "__wit_export_handle_ai_goal_stop") + private extern(C) void __export_handleAiGoalStop(uint arg0, uint arg1, uint arg2) { + auto _handle0 = ServerInstance(arg1); + auto _handle1 = Entity(arg2); + handleAiGoalStop_Impl(arg0, _handle0, _handle1); + } + + /++ + Dispatches a chunk generation phase to the plugin. + +/ + alias handleGeneratePhase_Sig = void function(uint generatorId, GenerationPhase phase, ChunkBuffer chunk); + /// ditto + alias handleGeneratePhase_Impl = findWitExportFunc!("$root", "handle-generate-phase", handleGeneratePhase_Sig, Impl); + /// ditto + @wasmExport!("handle-generate-phase") + pragma(mangle, "__wit_export_handle_generate_phase") + private extern(C) void __export_handleGeneratePhase(uint arg0, uint arg1, uint arg2) { + auto _handle0 = ChunkBuffer(arg2); + handleGeneratePhase_Impl(arg0, cast(wit.pumpkin.plugin.world.common.GenerationPhase)(arg1), _handle0); + } + + align(8) private void[(344+62*size_t.sizeof)] _exportsRetArea; +} +private enum componentTypeBytes = x" +0061736D0D0001000019167769742D636F6D706F6E656E742D656E636F64696E67040007E29E0E +0141020141F101014207016D0505747261636505646562756704696E666F047761726E05657272 +6F720400056C6576656C030000014002056C6576656C01076D6573736167657301000400036C6F +67010201707D014001056576656E7403010004000B6C6F672D74726163696E67010403001C7075 +6D706B696E3A706C7567696E2F6C6F6767696E6740302E312E30050001422201707D0400127261 +772D746578742D636F6D706F6E656E74030000017202036B6579730576616C7565790400096E62 +742D656E74727903000201707E01707901700301707A01707801710C0462797465017E00057368 +6F7274017C0003696E74017A00046C6F6E6701780005666C6F617401760006646F75626C650175 +000A627974652D61727261790104000A737472696E672D746167017300086C6973742D74616701 +050008636F6D706F756E6401060009696E742D61727261790107000A6C6F6E672D617272617901 +08000400076E62742D74616703000901700A01720204726F6F747904746167730B0400086E6274 +2D7472656503000C01720301787A01797A017A7A040009626C6F636B2D706F7303000E016F0375 +7575040008706F736974696F6E030010016D02046C65667405726967687404000468616E640300 +12016D0408737572766976616C08637265617469766509616476656E7475726509737065637461 +746F7204000967616D652D6D6F6465030014016D1005626C61636B096461726B2D626C75650A64 +61726B2D677265656E096461726B2D61717561086461726B2D7265640B6461726B2D707572706C +6504676F6C640467726179096461726B2D6772617904626C756505677265656E04617175610372 +65640C6C696768742D707572706C650679656C6C6F7705776869746504000B6E616D65642D636F +6C6F7203001601720301727D01677D01627D0400097267622D636F6C6F7203001801720401617D +01727D01677D01627D04000A617267622D636F6C6F7203001A016D0A046C656674057269676874 +0A73686966742D6C6566740B73686966742D7269676874066D6964646C650464726F700C636F6E +74726F6C2D64726F700C646F75626C652D636C69636B0A6E756D6265722D6B657907756E6B6E6F +776E04000A636C69636B2D7479706503001C016D12087374616E64696E670B66616C6C2D666C79 +696E6708736C656570696E67087377696D6D696E670B7370696E2D61747461636B0963726F7563 +68696E670C6C6F6E672D6A756D70696E67056479696E670863726F616B696E670C7573696E672D +746F6E6775650773697474696E6707726F6172696E6708736E696666696E6708656D657267696E +670764696767696E6707736C6964696E670873686F6F74696E6708696E68616C696E6704000B65 +6E746974792D706F736503001E016D80010561662D7A610561722D7361066173742D657305617A +2D617A0562612D7275036261720562652D62790562672D62670562722D6672036272620562732D +62610563612D65730563732D637A0563792D67620564612D646B0564652D61740564652D636805 +64652D646505656C2D677205656E2D617505656E2D636105656E2D676205656E2D6E7A05656E2D +707405656E2D756405656E2D757303656E7004656E777305656F2D75790565732D61720565732D +636C0565732D65630565732D65730565732D6D780565732D75790565732D7665046573616E0565 +742D65650565752D65730566612D69720566692D66690666696C2D706805666F2D666F0566722D +63610566722D6672066672612D6465066675722D69740566792D6E6C0567612D69650567642D67 +6205676C2D6573066861772D75730568652D696C0568692D696E0568722D68720568752D687505 +68792D616D0569642D69640569672D6E6705696F2D656E0569732D6973036973760569742D6974 +056A612D6A70066A626F2D656E056B612D6765056B6B2D6B7A056B6E2D696E056B6F2D6B72036B +7368056B772D6762056C612D6C61056C622D6C75056C692D6C69036C6D6F056C6F2D6C61066C6F +6C2D7573056C742D6C74056C762D6C76036C7A68056D6B2D6D6B056D6E2D6D6E056D732D6D7905 +6D742D6D74036E6168066E64732D6465056E6C2D6265056E6C2D6E6C056E6E2D6E6F056E6F2D6E +6F056F632D6672036F766405706C2D706C0570742D62720570742D7074067179612D616105726F +2D726F037270720572752D72750572792D7561077361682D7361680573652D6E6F05736B2D736B +05736C2D736905736F2D736F0573712D616C0573722D63730573722D73700573762D7365037378 +7503737A6C0574612D696E0574682D746805746C2D706806746C682D616103746F6B0574722D74 +720574742D727505756B2D75610676616C2D6573067665632D69740576692D766E0579692D6465 +05796F2D6E67057A682D636E057A682D686B057A682D7477087A6C6D2D617261620400066C6F63 +616C6503002003001B70756D706B696E3A706C7567696E2F636F6D6D6F6E40302E312E30050102 +0300010B6E616D65642D636F6C6F7202030001097267622D636F6C6F72020300010A617267622D +636F6C6F72014251020302010204000B6E616D65642D636F6C6F72030000020302010304000972 +67622D636F6C6F72030002020302010404000A617267622D636F6C6F7203000404000E74657874 +2D636F6D706F6E656E74030101690601400105706C61696E73000704001B5B7374617469635D74 +6578742D636F6D706F6E656E742E746578740108017007014002036B6579730477697468090007 +0400205B7374617469635D746578742D636F6D706F6E656E742E7472616E736C617465010A0140 +03086A6176612D6B6579730B626564726F636B2D6B65797304776974680900070400265B737461 +7469635D746578742D636F6D706F6E656E742E7472616E736C6174652D63726F7373010B016B73 +0140020873656C6563746F727309736570617261746F720C00070400235B7374617469635D7465 +78742D636F6D706F6E656E742E656E746974792D6E616D6573010D014001076B657962696E6473 +000704001E5B7374617469635D746578742D636F6D706F6E656E742E6B657962696E64010E0140 +04096E616D65737061636573036B657973066C6F63616C6573047769746809000704001D5B7374 +617469635D746578742D636F6D706F6E656E742E637573746F6D010F01400105696E7075747300 +070400295B7374617469635D746578742D636F6D706F6E656E742E66726F6D2D6C65676163792D +737472696E67011001400205696E707574730B636F64652D73796D626F6C7400070400335B7374 +617469635D746578742D636F6D706F6E656E742E66726F6D2D6C65676163792D737472696E672D +776974682D636F64650111016A01070173014001046A736F6E7300120400205B7374617469635D +746578742D636F6D706F6E656E742E66726F6D2D6A736F6E01130168060140010473656C661400 +7304001E5B6D6574686F645D746578742D636F6D706F6E656E742E746F2D6A736F6E0115014002 +0473656C6614056368696C640701000400205B6D6574686F645D746578742D636F6D706F6E656E +742E6164642D6368696C6401160140020473656C6614047465787473010004001F5B6D6574686F +645D746578742D636F6D706F6E656E742E6164642D74657874011704001F5B6D6574686F645D74 +6578742D636F6D706F6E656E742E6765742D74657874011501707D0140010473656C6614001804 +001D5B6D6574686F645D746578742D636F6D706F6E656E742E656E636F646501190400285B6D65 +74686F645D746578742D636F6D706F6E656E742E746F2D7072657474792D636F6E736F6C650115 +0140020473656C661405636F6C6F720101000400225B6D6574686F645D746578742D636F6D706F +6E656E742E636F6C6F722D6E616D6564011A0140020473656C661405636F6C6F72030100040020 +5B6D6574686F645D746578742D636F6D706F6E656E742E636F6C6F722D726762011B0170010140 +020473656C661406636F6C6F72731C01000400255B6D6574686F645D746578742D636F6D706F6E +656E742E6772616469656E742D6E616D6564011D0170030140020473656C661406636F6C6F7273 +1E010004001F5B6D6574686F645D746578742D636F6D706F6E656E742E6772616469656E74011F +0140010473656C6614010004001E5B6D6574686F645D746578742D636F6D706F6E656E742E7261 +696E626F7701200140020473656C66140576616C75657F010004001B5B6D6574686F645D746578 +742D636F6D706F6E656E742E626F6C64012104001D5B6D6574686F645D746578742D636F6D706F +6E656E742E6974616C696301210400215B6D6574686F645D746578742D636F6D706F6E656E742E +756E6465726C696E656401210400245B6D6574686F645D746578742D636F6D706F6E656E742E73 +7472696B657468726F75676801210400215B6D6574686F645D746578742D636F6D706F6E656E74 +2E6F62667573636174656401210400205B6D6574686F645D746578742D636F6D706F6E656E742E +696E73657274696F6E01170140020473656C661404666F6E7473010004001B5B6D6574686F645D +746578742D636F6D706F6E656E742E666F6E7401220140020473656C661405636F6C6F72050100 +0400235B6D6574686F645D746578742D636F6D706F6E656E742E736861646F772D636F6C6F7201 +230140020473656C66140375726C7301000400255B6D6574686F645D746578742D636F6D706F6E +656E742E636C69636B2D6F70656E2D75726C01240140020473656C661404706174687301000400 +265B6D6574686F645D746578742D636F6D706F6E656E742E636C69636B2D6F70656E2D66696C65 +01250140020473656C661407636F6D6D616E647301000400285B6D6574686F645D746578742D63 +6F6D706F6E656E742E636C69636B2D72756E2D636F6D6D616E64012604002C5B6D6574686F645D +746578742D636F6D706F6E656E742E636C69636B2D737567676573742D636F6D6D616E64012601 +40020473656C661404706167657901000400285B6D6574686F645D746578742D636F6D706F6E65 +6E742E636C69636B2D6368616E67652D70616765012704002E5B6D6574686F645D746578742D63 +6F6D706F6E656E742E636C69636B2D636F70792D746F2D636C6970626F61726401170140020473 +656C661404746578740701000400265B6D6574686F645D746578742D636F6D706F6E656E742E68 +6F7665722D73686F772D7465787401280140020473656C6614046974656D7301000400265B6D65 +74686F645D746578742D636F6D706F6E656E742E686F7665722D73686F772D6974656D0129016B +070140040473656C66140B656E746974792D747970657302696473046E616D652A01000400285B +6D6574686F645D746578742D636F6D706F6E656E742E686F7665722D73686F772D656E74697479 +012B03001970756D706B696E3A706C7567696E2F7465787440302E312E300505014206016D2811 +6169722D647261672D6D6F6469666965720561726D6F720F61726D6F722D746F7567686E657373 +0D61747461636B2D64616D6167651061747461636B2D6B6E6F636B6261636B0C61747461636B2D +73706565641362656C6F772D6E616D652D64697374616E636511626C6F636B2D627265616B2D73 +7065656417626C6F636B2D696E746572616374696F6E2D72616E67650A626F756E63696E657373 +0C6275726E696E672D74696D650F63616D6572612D64697374616E63651E6578706C6F73696F6E +2D6B6E6F636B6261636B2D726573697374616E636518656E746974792D696E746572616374696F +6E2D72616E67651666616C6C2D64616D6167652D6D756C7469706C6965720C666C79696E672D73 +706565640C666F6C6C6F772D72616E6765116672696374696F6E2D6D6F64696669657207677261 +766974790D6A756D702D737472656E677468146B6E6F636B6261636B2D726573697374616E6365 +046C75636B0E6D61782D6162736F727074696F6E0A6D61782D6865616C7468116D696E696E672D +656666696369656E6379136D6F76656D656E742D656666696369656E63790E6D6F76656D656E74 +2D7370656564116E616D652D7461672D64697374616E63650C6F787967656E2D626F6E75731273 +6166652D66616C6C2D64697374616E6365057363616C650E736E65616B696E672D737065656414 +737061776E2D7265696E666F7263656D656E74730B737465702D686569676874167375626D6572 +6765642D6D696E696E672D7370656564157377656570696E672D64616D6167652D726174696F0B +74656D70742D72616E67651977617465722D6D6F76656D656E742D656666696369656E63791777 +6179706F696E742D7472616E736D69742D72616E676516776179706F696E742D72656365697665 +2D72616E6765040009617474726962757465030000016D03036164640D6D756C7469706C792D62 +6173650E6D756C7469706C792D746F74616C0400126D6F6469666965722D6F7065726174696F6E +0300020172030269647306616D6F756E7475096F7065726174696F6E0304001261747472696275 +74652D6D6F64696669657203000403001F70756D706B696E3A706C7567696E2F61747472696275 +74657340302E312E300506014202016D6F0B637573746F6D2D646174610E6D61782D737461636B +2D73697A650A6D61782D64616D6167650664616D6167650B756E627265616B61626C650B757365 +2D656666656374730B637573746F6D2D6E616D65156D696E696D756D2D61747461636B2D636861 +7267650B64616D6167652D74797065096974656D2D6E616D650A6974656D2D6D6F64656C046C6F +7265067261726974790C656E6368616E746D656E74730C63616E2D706C6163652D6F6E0963616E +2D627265616B136174747269627574652D6D6F6469666965727311637573746F6D2D6D6F64656C +2D646174610F746F6F6C7469702D646973706C61790B7265706169722D636F7374126372656174 +6976652D736C6F742D6C6F636B1A656E6368616E746D656E742D676C696E742D6F766572726964 +6515696E74616E6769626C652D70726F6A656374696C6504666F6F640A636F6E73756D61626C65 +0D7573652D72656D61696E6465720C7573652D636F6F6C646F776E1064616D6167652D72657369 +7374616E7404746F6F6C06776561706F6E0C61747461636B2D72616E67650B656E6368616E7461 +626C650A65717569707061626C650A72657061697261626C6506676C696465720D746F6F6C7469 +702D7374796C651064656174682D70726F74656374696F6E0E626C6F636B732D61747461636B73 +0F7069657263696E672D776561706F6E0E6B696E657469632D776561706F6E0F7377696E672D61 +6E696D6174696F6E156164646974696F6E616C2D74726164652D636F73741373746F7265642D65 +6E6368616E746D656E7473036479650A647965642D636F6C6F72096D61702D636F6C6F72066D61 +702D69640F6D61702D6465636F726174696F6E73136D61702D706F73742D70726F63657373696E +6713636861726765642D70726F6A656374696C65730F62756E646C652D636F6E74656E74730F70 +6F74696F6E2D636F6E74656E747315706F74696F6E2D6475726174696F6E2D7363616C65177375 +73706963696F75732D737465772D65666665637473157772697461626C652D626F6F6B2D636F6E +74656E74147772697474656E2D626F6F6B2D636F6E74656E74047472696D1164656275672D7374 +69636B2D73746174650B656E746974792D64617461126275636B65742D656E746974792D646174 +6111626C6F636B2D656E746974792D646174610A696E737472756D656E741670726F7669646573 +2D7472696D2D6D6174657269616C186F6D696E6F75732D626F74746C652D616D706C6966696572 +106A756B65626F782D706C617961626C651870726F76696465732D62616E6E65722D7061747465 +726E730772656369706573116C6F646573746F6E652D747261636B65721266697265776F726B2D +6578706C6F73696F6E0966697265776F726B730770726F66696C65106E6F74652D626C6F636B2D +736F756E640F62616E6E65722D7061747465726E730A626173652D636F6C6F720F706F742D6465 +636F726174696F6E7309636F6E7461696E65720B626C6F636B2D73746174650462656573137375 +6C6675722D637562652D636F6E74656E74046C6F636B0E636F6E7461696E65722D6C6F6F740B62 +7265616B2D736F756E641076696C6C616765722D76617269616E740C776F6C662D76617269616E +7412776F6C662D736F756E642D76617269616E740B776F6C662D636F6C6C61720B666F782D7661 +7269616E740B73616C6D6F6E2D73697A650E706172726F742D76617269616E741574726F706963 +616C2D666973682D7061747465726E1874726F706963616C2D666973682D626173652D636F6C6F +721B74726F706963616C2D666973682D7061747465726E2D636F6C6F72116D6F6F7368726F6F6D +2D76617269616E740E7261626269742D76617269616E740B7069672D76617269616E7411706967 +2D736F756E642D76617269616E740B636F772D76617269616E7411636F772D736F756E642D7661 +7269616E740F636869636B656E2D76617269616E7415636869636B656E2D736F756E642D766172 +69616E74177A6F6D6269652D6E617574696C75732D76617269616E740C66726F672D7661726961 +6E740D686F7273652D76617269616E74107061696E74696E672D76617269616E740D6C6C616D61 +2D76617269616E740F61786F6C6F746C2D76617269616E740B6361742D76617269616E74116361 +742D736F756E642D76617269616E740A6361742D636F6C6C61720B73686565702D636F6C6F720D +7368756C6B65722D636F6C6F7204000E646174612D636F6D706F6E656E7403000003002470756D +706B696E3A706C7567696E2F646174612D636F6D706F6E656E747340302E312E30050702030002 +0E746578742D636F6D706F6E656E74014217020302010804000E746578742D636F6D706F6E656E +74030000016D0B03616E79096D61696E2D68616E64086F66662D68616E640468616E6404666565 +74046C65677305636865737404686561640561726D6F7204626F647906736164646C6504001761 +74747269627574652D6D6F6469666965722D736C6F74030002016D2B0D617175612D616666696E +6974791262616E652D6F662D61727468726F706F64730D62696E64696E672D637572736510626C +6173742D70726F74656374696F6E066272656163680A6368616E6E656C696E670764656E736974 +790D64657074682D737472696465720A656666696369656E63790F666561746865722D66616C6C +696E670B666972652D6173706563740F666972652D70726F74656374696F6E05666C616D650766 +6F7274756E650C66726F73742D77616C6B657208696D70616C696E6708696E66696E697479096B +6E6F636B6261636B076C6F6F74696E67076C6F79616C74790F6C75636B2D6F662D7468652D7365 +61056C756E6765046C757265076D656E64696E67096D756C746973686F74087069657263696E67 +05706F7765721570726F6A656374696C652D70726F74656374696F6E0A70726F74656374696F6E +0570756E63680C717569636B2D6368617267650B7265737069726174696F6E0772697074696465 +0973686172706E6573730A73696C6B2D746F75636805736D6974650A736F756C2D73706565640D +7377656570696E672D656467650B73776966742D736E65616B0674686F726E730A756E62726561 +6B696E670F76616E697368696E672D63757273650A77696E642D627572737404000B656E636861 +6E746D656E74030004016901017003017073017208026964730B6465736372697074696F6E0609 +6D61782D6C6576656C790A616E76696C2D636F7374790F737570706F727465642D6974656D7373 +067765696768747905736C6F7473070D6578636C75736976652D73657408040012637573746F6D +2D656E6368616E746D656E74030009040013656E6368616E746D656E742D6D616E616765720301 +01680B016A0001730140020473656C660C0B656E6368616E746D656E740A000D0400305B6D6574 +686F645D656E6368616E746D656E742D6D616E616765722E72656769737465722D656E6368616E +746D656E74010E016B0A0140020473656C660C02696473000F04002B5B6D6574686F645D656E63 +68616E746D656E742D6D616E616765722E6765742D656E6368616E746D656E7401100140020473 +656C660C02696473007F04002B5B6D6574686F645D656E6368616E746D656E742D6D616E616765 +722E6861732D656E6368616E746D656E7401110140010473656C660C00080400335B6D6574686F +645D656E6368616E746D656E742D6D616E616765722E6765742D616C6C2D656E6368616E746D65 +6E742D696473011203002170756D706B696E3A706C7567696E2F656E6368616E746D656E747340 +302E312E300509020300030961747472696275746502030003126174747269627574652D6D6F64 +6966696572020300040E646174612D636F6D706F6E656E7402030005176174747269627574652D +6D6F6469666965722D736C6F74020300050B656E6368616E746D656E7402030001096E62742D65 +6E74727902030001086E62742D7472656502030001076E62742D746167014260020302010A0400 +09617474726962757465030000020302010B0400126174747269627574652D6D6F646966696572 +030002020302010C04000E646174612D636F6D706F6E656E74030004020302010D040017617474 +7269627574652D6D6F6469666965722D736C6F74030006020302010E04000B656E6368616E746D +656E74030008020302010804000E746578742D636F6D706F6E656E7403000A020302010F040009 +6E62742D656E74727903000C02030201100400086E62742D7472656503000E0203020111040007 +6E62742D7461670300100172020B656E6368616E746D656E7409056C6576656C79040011656E63 +68616E746D656E742D76616C75650300120172020E656E6368616E746D656E742D696473056C65 +76656C79040018637573746F6D2D656E6368616E746D656E742D76616C75650300140172030961 +747472696275746501086D6F6469666965720304736C6F74070400176974656D2D617474726962 +7574652D6D6F64696669657203001601707D01720209636F6D706F6E656E74050576616C756518 +040014646174612D636F6D706F6E656E742D76616C756503001904000A6974656D2D737461636B +030101691B0140020C72656769737472792D6B65797305636F756E747D001C0400175B636F6E73 +74727563746F725D6974656D2D737461636B011D01681B0140010473656C661E00730400235B6D +6574686F645D6974656D2D737461636B2E6765742D72656769737472792D6B6579011F01400104 +73656C661E007D04001C5B6D6574686F645D6974656D2D737461636B2E6765742D636F756E7401 +200140020473656C661E05636F756E747D010004001C5B6D6574686F645D6974656D2D73746163 +6B2E7365742D636F756E7401210400205B6D6574686F645D6974656D2D737461636B2E6765742D +6D61782D636F756E7401200170130140010473656C661E00220400235B6D6574686F645D697465 +6D2D737461636B2E6765742D656E6368616E746D656E747301230140030473656C661E0B656E63 +68616E746D656E7409056C6576656C7901000400225B6D6574686F645D6974656D2D737461636B +2E6164642D656E6368616E746D656E7401240140020473656C661E0B656E6368616E746D656E74 +0901000400255B6D6574686F645D6974656D2D737461636B2E72656D6F76652D656E6368616E74 +6D656E7401250170150140010473656C661E002604002A5B6D6574686F645D6974656D2D737461 +636B2E6765742D637573746F6D2D656E6368616E746D656E747301270140030473656C661E0E65 +6E6368616E746D656E742D696473056C6576656C7901000400295B6D6574686F645D6974656D2D +737461636B2E6164642D637573746F6D2D656E6368616E746D656E7401280140020473656C661E +0E656E6368616E746D656E742D696473010004002C5B6D6574686F645D6974656D2D737461636B +2E72656D6F76652D637573746F6D2D656E6368616E746D656E740129016B790140020473656C66 +1E0E656E6368616E746D656E742D696473002A04002F5B6D6574686F645D6974656D2D73746163 +6B2E6765742D637573746F6D2D656E6368616E746D656E742D6C6576656C012B0140020473656C +661E0E656E6368616E746D656E742D696473007F0400295B6D6574686F645D6974656D2D737461 +636B2E6861732D637573746F6D2D656E6368616E746D656E74012C0170170140010473656C661E +002D04002A5B6D6574686F645D6974656D2D737461636B2E6765742D6174747269627574652D6D +6F64696669657273012E0140020473656C661E086D6F6469666965721701000400295B6D657468 +6F645D6974656D2D737461636B2E6164642D6174747269627574652D6D6F646966696572012F01 +40020473656C661E0961747472696275746501010004002D5B6D6574686F645D6974656D2D7374 +61636B2E72656D6F76652D6174747269627574652D6D6F6469666965727301300140010473656C +661E010004002C5B6D6574686F645D6974656D2D737461636B2E636C6561722D61747472696275 +74652D6D6F64696669657273013101690B0170320140010473656C661E003304001B5B6D657468 +6F645D6974656D2D737461636B2E6765742D6C6F726501340140020473656C661E046C6F726533 +010004001B5B6D6574686F645D6974656D2D737461636B2E7365742D6C6F726501350140020473 +656C661E046C696E6532010004001B5B6D6574686F645D6974656D2D737461636B2E6164642D6C +6F72650136016B320140010473656C661E00370400225B6D6574686F645D6974656D2D73746163 +6B2E6765742D637573746F6D2D6E616D6501380140020473656C661E046E616D65370100040022 +5B6D6574686F645D6974656D2D737461636B2E7365742D637573746F6D2D6E616D650139014004 +0473656C661E096E616D65737061636573036B6579730576616C75650F01000400225B6D657468 +6F645D6974656D2D737461636B2E7365742D637573746F6D2D64617461013A016B0F0140030473 +656C661E096E616D65737061636573036B657973003B0400225B6D6574686F645D6974656D2D73 +7461636B2E6765742D637573746F6D2D64617461013C0140030473656C661E096E616D65737061 +636573036B65797301000400255B6D6574686F645D6974656D2D737461636B2E72656D6F76652D +637573746F6D2D64617461013D0140030473656C661E096E616D65737061636573036B65797300 +7F0400225B6D6574686F645D6974656D2D737461636B2E6861732D637573746F6D2D6461746101 +3E01701A0140010473656C661E003F0400215B6D6574686F645D6974656D2D737461636B2E6765 +742D636F6D706F6E656E747301400140030473656C661E09636F6D706F6E656E74050576616C75 +651801000400205B6D6574686F645D6974656D2D737461636B2E7365742D636F6D706F6E656E74 +01410140020473656C661E09636F6D706F6E656E740501000400235B6D6574686F645D6974656D +2D737461636B2E72656D6F76652D636F6D706F6E656E74014203001F70756D706B696E3A706C75 +67696E2F6974656D2D737461636B40302E312E300512014202016D190B67656E657269632D3978 +310B67656E657269632D3978320B67656E657269632D3978330B67656E657269632D3978340B67 +656E657269632D3978350B67656E657269632D3978360B67656E657269632D3378330B63726166 +7465722D33783305616E76696C06626561636F6E0D626C6173742D6675726E6163650D62726577 +696E672D7374616E64086372616674696E670B656E6368616E746D656E74076675726E6163650A +6772696E6473746F6E6506686F70706572076C65637465726E046C6F6F6D086D65726368616E74 +0B7368756C6B65722D626F7808736D697468696E6706736D6F6B657211636172746F6772617068 +792D7461626C650B73746F6E6563757474657204000673637265656E03000003001C70756D706B +696E3A706C7567696E2F73637265656E7340302E312E300513020300060A6974656D2D73746163 +6B020300010468616E64014239020302011404000A6974656D2D737461636B0300000203020115 +04000468616E64030002040009696E76656E746F72790301040010706C617965722D696E76656E +746F727903010168040140010473656C6606007904001A5B6D6574686F645D696E76656E746F72 +792E6765742D73697A6501070140010473656C6606007F04001A5B6D6574686F645D696E76656E +746F72792E69732D656D7074790108016901016B090140020473656C660604736C6F7479000A04 +001A5B6D6574686F645D696E76656E746F72792E6765742D6974656D010B0140030473656C6606 +04736C6F7479046974656D0A010004001A5B6D6574686F645D696E76656E746F72792E7365742D +6974656D010C04001D5B6D6574686F645D696E76656E746F72792E72656D6F76652D6974656D01 +0B0140010473656C660601000400175B6D6574686F645D696E76656E746F72792E636C65617201 +0D01700A0140010473656C6606000E04001F5B6D6574686F645D696E76656E746F72792E676574 +2D616C6C2D6974656D73010F0140020473656C6606056974656D730E010004001F5B6D6574686F +645D696E76656E746F72792E7365742D616C6C2D6974656D7301100140020473656C6606076974 +656D2D696473007904001C5B6D6574686F645D696E76656E746F72792E636F756E742D6974656D +01110140020473656C6606076974656D2D696473007F04001F5B6D6574686F645D696E76656E74 +6F72792E636F6E7461696E732D6974656D01120168050169040140010473656C66130014040025 +5B6D6574686F645D706C617965722D696E76656E746F72792E61732D696E76656E746F72790115 +0140020473656C66130468616E6403000A0400295B6D6574686F645D706C617965722D696E7665 +6E746F72792E6765742D6974656D2D696E2D68616E6401160140030473656C66130468616E6403 +046974656D0A01000400295B6D6574686F645D706C617965722D696E76656E746F72792E736574 +2D6974656D2D696E2D68616E6401170140010473656C6613007D04002A5B6D6574686F645D706C +617965722D696E76656E746F72792E6765742D73656C65637465642D736C6F7401180140020473 +656C661304736C6F747D010004002A5B6D6574686F645D706C617965722D696E76656E746F7279 +2E7365742D73656C65637465642D736C6F7401190140010473656C6613000A0400235B6D657468 +6F645D706C617965722D696E76656E746F72792E6765742D68656C6D6574011A0140020473656C +6613046974656D0A01000400235B6D6574686F645D706C617965722D696E76656E746F72792E73 +65742D68656C6D6574011B0400275B6D6574686F645D706C617965722D696E76656E746F72792E +6765742D6368657374706C617465011A0400275B6D6574686F645D706C617965722D696E76656E +746F72792E7365742D6368657374706C617465011B0400255B6D6574686F645D706C617965722D +696E76656E746F72792E6765742D6C656767696E6773011A0400255B6D6574686F645D706C6179 +65722D696E76656E746F72792E7365742D6C656767696E6773011B0400225B6D6574686F645D70 +6C617965722D696E76656E746F72792E6765742D626F6F7473011A0400225B6D6574686F645D70 +6C617965722D696E76656E746F72792E7365742D626F6F7473011B0400255B6D6574686F645D70 +6C617965722D696E76656E746F72792E6765742D6F66662D68616E64011A0400255B6D6574686F +645D706C617965722D696E76656E746F72792E7365742D6F66662D68616E64011B014001047365 +6C661301000400245B6D6574686F645D706C617965722D696E76656E746F72792E636C6561722D +61726D6F72011C0400235B6D6574686F645D706C617965722D696E76656E746F72792E636C6561 +722D6D61696E011C0400225B6D6574686F645D706C617965722D696E76656E746F72792E636C65 +61722D616C6C011C03001E70756D706B696E3A706C7567696E2F696E76656E746F727940302E31 +2E300516020300010A636C69636B2D74797065020300070673637265656E0203000809696E7665 +6E746F7279014227020302010804000E746578742D636F6D706F6E656E74030000020302011704 +000A636C69636B2D74797065030002020302011404000A6974656D2D737461636B030004020302 +011804000673637265656E0300060203020119040009696E76656E746F72790300080400036775 +69030101690101690A014002047479706507057469746C650B000C0400105B636F6E7374727563 +746F725D677569010D01680A0169090140010473656C660E000F0400195B6D6574686F645D6775 +692E6765742D696E76656E746F727901100169050140030473656C660E04736C6F747904697465 +6D1101000400145B6D6574686F645D6775692E7365742D6974656D0112016B110140020473656C +660E04736C6F747900130400145B6D6574686F645D6775692E6765742D6974656D011401400104 +73656C660E00070400145B6D6574686F645D6775692E6765742D7479706501150140010473656C +660E000B0400155B6D6574686F645D6775692E6765742D7469746C6501160140010473656C660E +00790400145B6D6574686F645D6775692E6765742D73697A6501170140010473656C660E010004 +00175B6D6574686F645D6775692E636C6561722D6974656D7301180140020473656C660E05616C +6C6F777F01000400205B6D6574686F645D6775692E7365742D616C6C6F772D677261622D697465 +6D7301190140010473656C660E007F0400205B6D6574686F645D6775692E6765742D616C6C6F77 +2D677261622D6974656D73011A04001F5B6D6574686F645D6775692E7365742D616C6C6F772D70 +75742D6974656D73011904001F5B6D6574686F645D6775692E6765742D616C6C6F772D7075742D +6974656D73011A03001870756D706B696E3A706C7567696E2F67756940302E312E30051A014250 +020302010804000E746578742D636F6D706F6E656E74030000020302010204000B6E616D65642D +636F6C6F72030002016D0207696E74656765720668656172747304000B72656E6465722D747970 +6503000401690101710205626C616E6B000005666978656401060004000D6E756D6265722D666F +726D6174030007016D130B706C617965722D6C69737407736964656261720A62656C6F772D6E61 +6D6512736964656261722D7465616D2D626C61636B16736964656261722D7465616D2D6461726B +2D626C756517736964656261722D7465616D2D6461726B2D677265656E16736964656261722D74 +65616D2D6461726B2D6171756115736964656261722D7465616D2D6461726B2D72656418736964 +656261722D7465616D2D6461726B2D707572706C6511736964656261722D7465616D2D676F6C64 +11736964656261722D7465616D2D6772617916736964656261722D7465616D2D6461726B2D6772 +617911736964656261722D7465616D2D626C756512736964656261722D7465616D2D677265656E +11736964656261722D7465616D2D6171756110736964656261722D7465616D2D72656419736964 +656261722D7465616D2D6C696768742D707572706C6513736964656261722D7465616D2D79656C +6C6F7712736964656261722D7465616D2D776869746504000C646973706C61792D736C6F740300 +09016D0406616C77617973056E6576657214686964652D666F722D6F746865722D7465616D7311 +686964652D666F722D6F776E2D7465616D0400126E616D657461672D7669736962696C69747903 +000B016D0406616C77617973056E6576657210707573682D6F746865722D7465616D730D707573 +682D6F776E2D7465616D04000E636F6C6C6973696F6E2D72756C6503000D0172080C646973706C +61792D6E616D65060D667269656E646C792D666972657F177365652D667269656E646C792D696E +76697369626C65737F126E616D657461672D7669736962696C6974790C0E636F6C6C6973696F6E +2D72756C650E05636F6C6F72030670726566697806067375666669780604000D7465616D2D7365 +7474696E677303000F04000A73636F7265626F6172640301016D0209617363656E64696E670A64 +657363656E64696E67040012626564726F636B2D736F72742D6F72646572030012016D030B706C +617965722D6C69737407736964656261720A62656C6F772D6E616D65040014626564726F636B2D +646973706C61792D736C6F74030014040012626564726F636B2D73636F7265626F617264030101 +6811016B080140050473656C6617046E616D65730C646973706C61792D6E616D65060B72656E64 +65722D74797065050D6E756D6265722D666F726D61741801000400205B6D6574686F645D73636F +7265626F6172642E6164642D6F626A65637469766501190400235B6D6574686F645D73636F7265 +626F6172642E7570646174652D6F626A65637469766501190140020473656C6617046E616D6573 +01000400235B6D6574686F645D73636F7265626F6172642E72656D6F76652D6F626A6563746976 +65011A0140030473656C661704736C6F740A0E6F626A6563746976652D6E616D65730100040023 +5B6D6574686F645D73636F7265626F6172642E7365742D646973706C61792D736C6F74011B0140 +020473656C661704736C6F740A01000400255B6D6574686F645D73636F7265626F6172642E636C +6561722D646973706C61792D736C6F74011C0140050473656C66170B656E746974792D6E616D65 +730E6F626A6563746976652D6E616D65730576616C75657A0D6E756D6265722D666F726D617418 +010004001F5B6D6574686F645D73636F7265626F6172642E7570646174652D73636F7265011D01 +40040473656C66170B656E746974792D6E616D65730E6F626A6563746976652D6E616D65730564 +656C74617A007A04001C5B6D6574686F645D73636F7265626F6172642E6164642D73636F726501 +1E0140030473656C66170B656E746974792D6E616D65730E6F626A6563746976652D6E616D6573 +010004001F5B6D6574686F645D73636F7265626F6172642E72656D6F76652D73636F7265011F01 +40020473656C66170B656E746974792D6E616D657301000400265B6D6574686F645D73636F7265 +626F6172642E72657365742D656E746974792D73636F72657301200140030473656C6617046E61 +6D65730873657474696E677310010004001E5B6D6574686F645D73636F7265626F6172642E6372 +656174652D7465616D012104001E5B6D6574686F645D73636F7265626F6172642E72656D6F7665 +2D7465616D011A04001E5B6D6574686F645D73636F7265626F6172642E7570646174652D746561 +6D01210140030473656C6617097465616D2D6E616D65730B706C617965722D6E616D6573010004 +00255B6D6574686F645D73636F7265626F6172642E6164642D706C617965722D746F2D7465616D +012204002A5B6D6574686F645D73636F7265626F6172642E72656D6F76652D706C617965722D66 +726F6D2D7465616D01220140020473656C6617097465616D2D6E616D657301000400255B6D6574 +686F645D73636F7265626F6172642E636C6561722D7465616D2D706C6179657273012301707301 +40010473656C6617002404001C5B6D6574686F645D73636F7265626F6172642E6765742D746561 +6D730125016B100140020473656C6617046E616D6573002604001B5B6D6574686F645D73636F72 +65626F6172642E6765742D7465616D01270140020473656C6617097465616D2D6E616D65730024 +0400235B6D6574686F645D73636F7265626F6172642E6765742D7465616D2D706C617965727301 +28016B730140020473656C66170B706C617965722D6E616D657300290400225B6D6574686F645D +73636F7265626F6172642E6765742D706C617965722D7465616D012A0168160140040473656C66 +2B046E616D65730C646973706C61792D6E616D65730A736F72742D6F726465721301000400285B +6D6574686F645D626564726F636B2D73636F7265626F6172642E6164642D6F626A656374697665 +012C04002B5B6D6574686F645D626564726F636B2D73636F7265626F6172642E7570646174652D +6F626A656374697665012C0140020473656C662B046E616D6573010004002B5B6D6574686F645D +626564726F636B2D73636F7265626F6172642E72656D6F76652D6F626A656374697665012D0140 +030473656C662B04736C6F74150E6F626A6563746976652D6E616D6573010004002B5B6D657468 +6F645D626564726F636B2D73636F7265626F6172642E7365742D646973706C61792D736C6F7401 +2E0140020473656C662B04736C6F7415010004002D5B6D6574686F645D626564726F636B2D7363 +6F7265626F6172642E636C6561722D646973706C61792D736C6F74012F0140040473656C662B0B +656E746974792D6E616D65730E6F626A6563746976652D6E616D65730576616C75657A01000400 +275B6D6574686F645D626564726F636B2D73636F7265626F6172642E7570646174652D73636F72 +6501300140040473656C662B0B656E746974792D6E616D65730E6F626A6563746976652D6E616D +65730564656C74617A007A0400245B6D6574686F645D626564726F636B2D73636F7265626F6172 +642E6164642D73636F726501310140030473656C662B0B656E746974792D6E616D65730E6F626A +6563746976652D6E616D657301000400275B6D6574686F645D626564726F636B2D73636F726562 +6F6172642E72656D6F76652D73636F726501320140020473656C662B0B656E746974792D6E616D +6573010004002E5B6D6574686F645D626564726F636B2D73636F7265626F6172642E7265736574 +2D656E746974792D73636F726573013303001F70756D706B696E3A706C7567696E2F73636F7265 +626F61726440302E312E30051B0203000109626C6F636B2D706F730142F003020302011C040009 +626C6F636B2D706F7303000002030201100400086E62742D74726565030002020302011404000A +6974656D2D737461636B0300040203020119040009696E76656E746F727903000604000C626C6F +636B2D656E746974790301040016636F6E7461696E65722D626C6F636B2D656E74697479030104 +0014636F6D6D616E642D626C6F636B2D656E746974790301016D10057768697465066F72616E67 +65076D6167656E74610A6C696768742D626C75650679656C6C6F77046C696D650470696E6B0467 +7261790A6C696768742D67726179046379616E06707572706C6504626C75650562726F776E0567 +7265656E0372656405626C61636B0400096479652D636F6C6F7203000B017073017203086D6573 +73616765730D05636F6C6F720C106861732D676C6F77696E672D746578747F0400097369676E2D +7465787403000E0400117369676E2D626C6F636B2D656E7469747903010400146A756B65626F78 +2D626C6F636B2D656E74697479030104001263686573742D626C6F636B2D656E74697479030104 +00186D6F622D737061776E65722D626C6F636B2D656E7469747903010400106D61702D626C6F63 +6B2D656E74697479030104001968616E67696E672D7369676E2D626C6F636B2D656E7469747903 +0104001A747261707065642D63686573742D626C6F636B2D656E74697479030104001362616E6E +65722D626C6F636B2D656E74697479030104001362617272656C2D626C6F636B2D656E74697479 +0301040013626561636F6E2D626C6F636B2D656E7469747903010400106265642D626C6F636B2D +656E746974790301040014626565686976652D626C6F636B2D656E74697479030104001162656C +6C2D626C6F636B2D656E74697479030104001D626C617374696E672D6675726E6163652D626C6F +636B2D656E74697479030104001A62726577696E672D7374616E642D626C6F636B2D656E746974 +79030104001C627275736861626C652D626C6F636B2D626C6F636B2D656E746974790301040024 +63616C696272617465642D7363756C6B2D73656E736F722D626C6F636B2D656E74697479030104 +001563616D70666972652D626C6F636B2D656E74697479030104001F63686973656C65642D626F +6F6B7368656C662D626C6F636B2D656E746974790301040017636F6D70617261746F722D626C6F +636B2D656E746974790301040014636F6E647569742D626C6F636B2D656E746974790301040020 +636F707065722D676F6C656D2D7374617475652D626C6F636B2D656E7469747903010400146372 +61667465722D626C6F636B2D656E74697479030104001B637265616B696E672D68656172742D62 +6C6F636B2D656E74697479030104001E6461796C696768742D6465746563746F722D626C6F636B +2D656E74697479030104001A6465636F72617465642D706F742D626C6F636B2D656E7469747903 +0104001664697370656E7365722D626C6F636B2D656E74697479030104001464726F707065722D +626C6F636B2D656E74697479030104001D656E6368616E74696E672D7461626C652D626C6F636B +2D656E746974790301040018656E642D676174657761792D626C6F636B2D656E74697479030104 +0017656E642D706F7274616C2D626C6F636B2D656E746974790301040018656E6465722D636865 +73742D626C6F636B2D656E7469747903010400146675726E6163652D626C6F636B2D656E746974 +790301040013686F707065722D626C6F636B2D656E7469747903010400136A69677361772D626C +6F636B2D656E7469747903010400146C65637465726E2D626C6F636B2D656E7469747903010400 +13706973746F6E2D626C6F636B2D656E74697479030104001A706F74656E742D73756C6675722D +626C6F636B2D656E74697479030104001B7363756C6B2D636174616C7973742D626C6F636B2D65 +6E7469747903010400197363756C6B2D73656E736F722D626C6F636B2D656E7469747903010400 +1B7363756C6B2D73687269656B65722D626C6F636B2D656E7469747903010400127368656C662D +626C6F636B2D656E7469747903010400187368756C6B65722D626F782D626C6F636B2D656E7469 +74790301040012736B756C6C2D626C6F636B2D656E746974790301040013736D6F6B65722D626C +6F636B2D656E74697479030104001C7374727563747572652D626C6F636B2D626C6F636B2D656E +746974790301040017746573742D626C6F636B2D626C6F636B2D656E7469747903010400207465 +73742D696E7374616E63652D626C6F636B2D626C6F636B2D656E74697479030104001A74726961 +6C2D737061776E65722D626C6F636B2D656E7469747903010400127661756C742D626C6F636B2D +656E74697479030101690A01691001691501691101691201691601691301691401691701691801 +691901691A01691B01691C01691D01691E01691F01692001692101692201692301692401692501 +692601692701692801692901692A01692B01692C01692D01692E01692F01693001693101693201 +693301693401693501693601693701693801693901693A01693B01693C01693D01693E01693F01 +694001694101690901713414636F6D6D616E642D626C6F636B2D656E7469747901C20000117369 +676E2D626C6F636B2D656E7469747901C300001968616E67696E672D7369676E2D626C6F636B2D +656E7469747901C40000146A756B65626F782D626C6F636B2D656E7469747901C5000012636865 +73742D626C6F636B2D656E7469747901C600001A747261707065642D63686573742D626C6F636B +2D656E7469747901C70000186D6F622D737061776E65722D626C6F636B2D656E7469747901C800 +00106D61702D626C6F636B2D656E7469747901C900001362616E6E65722D626C6F636B2D656E74 +69747901CA00001362617272656C2D626C6F636B2D656E7469747901CB000013626561636F6E2D +626C6F636B2D656E7469747901CC0000106265642D626C6F636B2D656E7469747901CD00001462 +6565686976652D626C6F636B2D656E7469747901CE00001162656C6C2D626C6F636B2D656E7469 +747901CF00001D626C617374696E672D6675726E6163652D626C6F636B2D656E7469747901D000 +001A62726577696E672D7374616E642D626C6F636B2D656E7469747901D100001C627275736861 +626C652D626C6F636B2D626C6F636B2D656E7469747901D200002463616C696272617465642D73 +63756C6B2D73656E736F722D626C6F636B2D656E7469747901D300001563616D70666972652D62 +6C6F636B2D656E7469747901D400001F63686973656C65642D626F6F6B7368656C662D626C6F63 +6B2D656E7469747901D5000017636F6D70617261746F722D626C6F636B2D656E7469747901D600 +0014636F6E647569742D626C6F636B2D656E7469747901D7000020636F707065722D676F6C656D +2D7374617475652D626C6F636B2D656E7469747901D8000014637261667465722D626C6F636B2D +656E7469747901D900001B637265616B696E672D68656172742D626C6F636B2D656E7469747901 +DA00001E6461796C696768742D6465746563746F722D626C6F636B2D656E7469747901DB00001A +6465636F72617465642D706F742D626C6F636B2D656E7469747901DC00001664697370656E7365 +722D626C6F636B2D656E7469747901DD00001464726F707065722D626C6F636B2D656E74697479 +01DE00001D656E6368616E74696E672D7461626C652D626C6F636B2D656E7469747901DF000018 +656E642D676174657761792D626C6F636B2D656E7469747901E0000017656E642D706F7274616C +2D626C6F636B2D656E7469747901E1000018656E6465722D63686573742D626C6F636B2D656E74 +69747901E20000146675726E6163652D626C6F636B2D656E7469747901E3000013686F70706572 +2D626C6F636B2D656E7469747901E40000136A69677361772D626C6F636B2D656E7469747901E5 +0000146C65637465726E2D626C6F636B2D656E7469747901E6000013706973746F6E2D626C6F63 +6B2D656E7469747901E700001A706F74656E742D73756C6675722D626C6F636B2D656E74697479 +01E800001B7363756C6B2D636174616C7973742D626C6F636B2D656E7469747901E90000197363 +756C6B2D73656E736F722D626C6F636B2D656E7469747901EA00001B7363756C6B2D7368726965 +6B65722D626C6F636B2D656E7469747901EB0000127368656C662D626C6F636B2D656E74697479 +01EC0000187368756C6B65722D626F782D626C6F636B2D656E7469747901ED000012736B756C6C +2D626C6F636B2D656E7469747901EE000013736D6F6B65722D626C6F636B2D656E7469747901EF +00001C7374727563747572652D626C6F636B2D626C6F636B2D656E7469747901F0000017746573 +742D626C6F636B2D626C6F636B2D656E7469747901F1000020746573742D696E7374616E63652D +626C6F636B2D626C6F636B2D656E7469747901F200001A747269616C2D737061776E65722D626C +6F636B2D656E7469747901F30000127661756C742D626C6F636B2D656E7469747901F400001663 +6F6E7461696E65722D626C6F636B2D656E7469747901F50000040011626C6F636B2D656E746974 +792D747970650300760168080140010473656C66F80000730400265B6D6574686F645D626C6F63 +6B2D656E746974792E7265736F757263652D6C6F636174696F6E01790140010473656C66F80000 +010400215B6D6574686F645D626C6F636B2D656E746974792E6765742D706F736974696F6E017A +0140010473656C66F800007904001B5B6D6574686F645D626C6F636B2D656E746974792E676574 +2D6964017B0140010473656C66F800007F04001D5B6D6574686F645D626C6F636B2D656E746974 +792E69732D6469727479017C0140010473656C66F80001000400205B6D6574686F645D626C6F63 +6B2D656E746974792E636C6561722D6469727479017D0140040473656C66F800096E616D657370 +61636573036B6579730576616C75650301000400245B6D6574686F645D626C6F636B2D656E7469 +74792E7365742D637573746F6D2D64617461017E016B030140030473656C66F800096E616D6573 +7061636573036B65797300FF000400245B6D6574686F645D626C6F636B2D656E746974792E6765 +742D637573746F6D2D646174610180010140030473656C66F800096E616D65737061636573036B +65797301000400275B6D6574686F645D626C6F636B2D656E746974792E72656D6F76652D637573 +746F6D2D646174610181010140030473656C66F800096E616D65737061636573036B657973007F +0400245B6D6574686F645D626C6F636B2D656E746974792E6861732D637573746F6D2D64617461 +0182010168090169080140010473656C66830100840104002F5B6D6574686F645D636F6E746169 +6E65722D626C6F636B2D656E746974792E6765742D626C6F636B2D656E74697479018501016907 +0140010473656C66830100860104002C5B6D6574686F645D636F6E7461696E65722D626C6F636B +2D656E746974792E6765742D696E76656E746F72790187010140010473656C6683010079040027 +5B6D6574686F645D636F6E7461696E65722D626C6F636B2D656E746974792E6765742D73697A65 +0188010140010473656C668301007F0400275B6D6574686F645D636F6E7461696E65722D626C6F +636B2D656E746974792E69732D656D707479018901016905016B8A010140020473656C66830104 +736C6F7479008B010400285B6D6574686F645D636F6E7461696E65722D626C6F636B2D656E7469 +74792E6765742D737461636B018C010140030473656C66830104736C6F747905737461636B8B01 +01000400285B6D6574686F645D636F6E7461696E65722D626C6F636B2D656E746974792E736574 +2D737461636B018D0104002B5B6D6574686F645D636F6E7461696E65722D626C6F636B2D656E74 +6974792E72656D6F76652D737461636B018C010140010473656C66830101000400245B6D657468 +6F645D636F6E7461696E65722D626C6F636B2D656E746974792E636C656172018E0101680A0140 +010473656C668F0100840104002D5B6D6574686F645D636F6D6D616E642D626C6F636B2D656E74 +6974792E6765742D626C6F636B2D656E746974790190010140010473656C668F0100730400285B +6D6574686F645D636F6D6D616E642D626C6F636B2D656E746974792E6C6173742D6F7574707574 +0191010140010473656C668F01007F0400295B6D6574686F645D636F6D6D616E642D626C6F636B +2D656E746974792E747261636B2D6F75747075740192010140010473656C668F01007904002A5B +6D6574686F645D636F6D6D616E642D626C6F636B2D656E746974792E737563636573732D636F75 +6E740193010400245B6D6574686F645D636F6D6D616E642D626C6F636B2D656E746974792E636F +6D6D616E640191010400215B6D6574686F645D636F6D6D616E642D626C6F636B2D656E74697479 +2E6175746F01920104002A5B6D6574686F645D636F6D6D616E642D626C6F636B2D656E74697479 +2E636F6E646974696F6E2D6D65740192010400245B6D6574686F645D636F6D6D616E642D626C6F +636B2D656E746974792E706F77657265640192010168100140010473656C66940100840104002A +5B6D6574686F645D7369676E2D626C6F636B2D656E746974792E6765742D626C6F636B2D656E74 +6974790195010140010473656C669401000F0400285B6D6574686F645D7369676E2D626C6F636B +2D656E746974792E6765742D66726F6E742D746578740196010140020473656C66940104746578 +740F01000400285B6D6574686F645D7369676E2D626C6F636B2D656E746974792E7365742D6672 +6F6E742D746578740197010400275B6D6574686F645D7369676E2D626C6F636B2D656E74697479 +2E6765742D6261636B2D746578740196010400275B6D6574686F645D7369676E2D626C6F636B2D +656E746974792E7365742D6261636B2D746578740197010140010473656C669401007F0400225B +6D6574686F645D7369676E2D626C6F636B2D656E746974792E69732D7761786564019801014002 +0473656C6694010577617865647F01000400235B6D6574686F645D7369676E2D626C6F636B2D65 +6E746974792E7365742D77617865640199010168110140010473656C669A0100840104002D5B6D +6574686F645D6A756B65626F782D626C6F636B2D656E746974792E6765742D626C6F636B2D656E +74697479019B010140010473656C669A0100F50004002A5B6D6574686F645D6A756B65626F782D +626C6F636B2D656E746974792E6765742D636F6E7461696E6572019C010140010473656C669A01 +007F0400275B6D6574686F645D6A756B65626F782D626C6F636B2D656E746974792E69732D706C +6179696E67019D010140010473656C669A0101000400295B6D6574686F645D6A756B65626F782D +626C6F636B2D656E746974792E73746F702D706C6179696E67019E010140020473656C669A010F +6C656E6774682D696E2D7469636B7377010004002A5B6D6574686F645D6A756B65626F782D626C +6F636B2D656E746974792E73746172742D706C6179696E67019F010168120140010473656C66A0 +0100840104002B5B6D6574686F645D63686573742D626C6F636B2D656E746974792E6765742D62 +6C6F636B2D656E7469747901A1010140010473656C66A00100F5000400285B6D6574686F645D63 +686573742D626C6F636B2D656E746974792E6765742D636F6E7461696E657201A2010140010473 +656C66A00100790400275B6D6574686F645D63686573742D626C6F636B2D656E746974792E7669 +657765722D636F756E7401A3010168130140010473656C66A4010084010400315B6D6574686F64 +5D6D6F622D737061776E65722D626C6F636B2D656E746974792E6765742D626C6F636B2D656E74 +69747901A5010140010473656C66A401007A0400305B6D6574686F645D6D6F622D737061776E65 +722D626C6F636B2D656E746974792E6765742D737061776E2D636F756E7401A6010400305B6D65 +74686F645D6D6F622D737061776E65722D626C6F636B2D656E746974792E6765742D737061776E +2D72616E676501A60104002A5B6D6574686F645D6D6F622D737061776E65722D626C6F636B2D65 +6E746974792E6765742D64656C617901A6010168140140010473656C66A7010084010400295B6D +6574686F645D6D61702D626C6F636B2D656E746974792E6765742D626C6F636B2D656E74697479 +01A8010140010473656C66A701007A0400235B6D6574686F645D6D61702D626C6F636B2D656E74 +6974792E6765742D6D61702D696401A9010140020473656C66A701066D61702D69647A01000400 +235B6D6574686F645D6D61702D626C6F636B2D656E746974792E7365742D6D61702D696401AA01 +01707D0140010473656C66A70100AB010400235B6D6574686F645D6D61702D626C6F636B2D656E +746974792E6765742D636F6C6F727301AC010140020473656C66A70106636F6C6F7273AB010100 +0400235B6D6574686F645D6D61702D626C6F636B2D656E746974792E7365742D636F6C6F727301 +AD010140040473656C66A70101787901797905636F6C6F727D01000400225B6D6574686F645D6D +61702D626C6F636B2D656E746974792E7365742D706978656C01AE010140030473656C66A70101 +7879017979007D0400225B6D6574686F645D6D61702D626C6F636B2D656E746974792E6765742D +706978656C01AF010140010473656C66A701010004001F5B6D6574686F645D6D61702D626C6F63 +6B2D656E746974792E75706461746501B0010140020473656C66A7010A6672616D652D64617461 +AB0101000400255B6D6574686F645D6D61702D626C6F636B2D656E746974792E73747265616D2D +6672616D6501B1010168150140010473656C66B2010084010400325B6D6574686F645D68616E67 +696E672D7369676E2D626C6F636B2D656E746974792E6765742D626C6F636B2D656E7469747901 +B3010140010473656C66B201000F0400305B6D6574686F645D68616E67696E672D7369676E2D62 +6C6F636B2D656E746974792E6765742D66726F6E742D7465787401B4010140020473656C66B201 +04746578740F01000400305B6D6574686F645D68616E67696E672D7369676E2D626C6F636B2D65 +6E746974792E7365742D66726F6E742D7465787401B50104002F5B6D6574686F645D68616E6769 +6E672D7369676E2D626C6F636B2D656E746974792E6765742D6261636B2D7465787401B4010400 +2F5B6D6574686F645D68616E67696E672D7369676E2D626C6F636B2D656E746974792E7365742D +6261636B2D7465787401B5010140010473656C66B201007F04002A5B6D6574686F645D68616E67 +696E672D7369676E2D626C6F636B2D656E746974792E69732D776178656401B601014002047365 +6C66B2010577617865647F010004002B5B6D6574686F645D68616E67696E672D7369676E2D626C +6F636B2D656E746974792E7365742D776178656401B7010168160140010473656C66B801008401 +0400335B6D6574686F645D747261707065642D63686573742D626C6F636B2D656E746974792E67 +65742D626C6F636B2D656E7469747901B9010140010473656C66B80100F5000400305B6D657468 +6F645D747261707065642D63686573742D626C6F636B2D656E746974792E6765742D636F6E7461 +696E657201BA010140010473656C66B801007904002F5B6D6574686F645D747261707065642D63 +686573742D626C6F636B2D656E746974792E7669657765722D636F756E7401BB01016817014001 +0473656C66BC0100840104002C5B6D6574686F645D62616E6E65722D626C6F636B2D656E746974 +792E6765742D626C6F636B2D656E7469747901BD01016B730140010473656C66BC0100BE010400 +2B5B6D6574686F645D62616E6E65722D626C6F636B2D656E746974792E6765742D637573746F6D +2D6E616D6501BF010168180140010473656C66C00100840104002C5B6D6574686F645D62617272 +656C2D626C6F636B2D656E746974792E6765742D626C6F636B2D656E7469747901C10101400104 +73656C66C00100F5000400295B6D6574686F645D62617272656C2D626C6F636B2D656E74697479 +2E6765742D636F6E7461696E657201C2010140010473656C66C00100790400285B6D6574686F64 +5D62617272656C2D626C6F636B2D656E746974792E7669657765722D636F756E7401C301016819 +0140010473656C66C40100840104002C5B6D6574686F645D626561636F6E2D626C6F636B2D656E +746974792E6765742D626C6F636B2D656E7469747901C5010140010473656C66C40100F5000400 +295B6D6574686F645D626561636F6E2D626C6F636B2D656E746974792E6765742D636F6E746169 +6E657201C6010140010473656C66C401007A04002E5B6D6574686F645D626561636F6E2D626C6F +636B2D656E746974792E6765742D7072696D6172792D65666665637401C7010400305B6D657468 +6F645D626561636F6E2D626C6F636B2D656E746974792E6765742D7365636F6E646172792D6566 +6665637401C7010400265B6D6574686F645D626561636F6E2D626C6F636B2D656E746974792E67 +65742D6C6576656C7301C70101681A0140010473656C66C8010084010400295B6D6574686F645D +6265642D626C6F636B2D656E746974792E6765742D626C6F636B2D656E7469747901C90101681B +0140010473656C66CA0100840104002D5B6D6574686F645D626565686976652D626C6F636B2D65 +6E746974792E6765742D626C6F636B2D656E7469747901CB010140010473656C66CA0100790400 +2A5B6D6574686F645D626565686976652D626C6F636B2D656E746974792E6765742D6265652D63 +6F756E7401CC0101681C0140010473656C66CD0100840104002A5B6D6574686F645D62656C6C2D +626C6F636B2D656E746974792E6765742D626C6F636B2D656E7469747901CE010140010473656C +66CD01007F0400245B6D6574686F645D62656C6C2D626C6F636B2D656E746974792E69732D7269 +6E67696E6701CF010140010473656C66CD01007A0400285B6D6574686F645D62656C6C2D626C6F +636B2D656E746974792E6765742D72696E672D7469636B7301D00101681D0140010473656C66D1 +010084010400365B6D6574686F645D626C617374696E672D6675726E6163652D626C6F636B2D65 +6E746974792E6765742D626C6F636B2D656E7469747901D2010140010473656C66D10100F50004 +00335B6D6574686F645D626C617374696E672D6675726E6163652D626C6F636B2D656E74697479 +2E6765742D636F6E7461696E657201D3010140010473656C66D101007B04003C5B6D6574686F64 +5D626C617374696E672D6675726E6163652D626C6F636B2D656E746974792E6765742D636F6F6B +696E672D74696D652D7370656E7401D40104003C5B6D6574686F645D626C617374696E672D6675 +726E6163652D626C6F636B2D656E746974792E6765742D636F6F6B696E672D746F74616C2D7469 +6D6501D40104003C5B6D6574686F645D626C617374696E672D6675726E6163652D626C6F636B2D +656E746974792E6765742D6C69742D74696D652D72656D61696E696E6701D4010400385B6D6574 +686F645D626C617374696E672D6675726E6163652D626C6F636B2D656E746974792E6765742D6C +69742D746F74616C2D74696D6501D4010140010473656C66D101007F0400305B6D6574686F645D +626C617374696E672D6675726E6163652D626C6F636B2D656E746974792E69732D6275726E696E +6701D50101681E0140010473656C66D6010084010400335B6D6574686F645D62726577696E672D +7374616E642D626C6F636B2D656E746974792E6765742D626C6F636B2D656E7469747901D70101 +40010473656C66D60100F5000400305B6D6574686F645D62726577696E672D7374616E642D626C +6F636B2D656E746974792E6765742D636F6E7461696E657201D8010140010473656C66D601007A +0400305B6D6574686F645D62726577696E672D7374616E642D626C6F636B2D656E746974792E67 +65742D627265772D74696D6501D90104002B5B6D6574686F645D62726577696E672D7374616E64 +2D626C6F636B2D656E746974792E6765742D6675656C01D90101681F0140010473656C66DA0100 +84010400355B6D6574686F645D627275736861626C652D626C6F636B2D626C6F636B2D656E7469 +74792E6765742D626C6F636B2D656E7469747901DB010168200140010473656C66DC0100840104 +003D5B6D6574686F645D63616C696272617465642D7363756C6B2D73656E736F722D626C6F636B +2D656E746974792E6765742D626C6F636B2D656E7469747901DD010168210140010473656C66DE +0100840104002E5B6D6574686F645D63616D70666972652D626C6F636B2D656E746974792E6765 +742D626C6F636B2D656E7469747901DF010140010473656C66DE0100F50004002B5B6D6574686F +645D63616D70666972652D626C6F636B2D656E746974792E6765742D636F6E7461696E657201E0 +010168220140010473656C66E1010084010400385B6D6574686F645D63686973656C65642D626F +6F6B7368656C662D626C6F636B2D656E746974792E6765742D626C6F636B2D656E7469747901E2 +010140010473656C66E10100F5000400355B6D6574686F645D63686973656C65642D626F6F6B73 +68656C662D626C6F636B2D656E746974792E6765742D636F6E7461696E657201E3010140010473 +656C66E101007E0400405B6D6574686F645D63686973656C65642D626F6F6B7368656C662D626C +6F636B2D656E746974792E6765742D6C6173742D696E74657261637465642D736C6F7401E40101 +68230140010473656C66E5010084010400305B6D6574686F645D636F6D70617261746F722D626C +6F636B2D656E746974792E6765742D626C6F636B2D656E7469747901E6010140010473656C66E5 +01007D0400315B6D6574686F645D636F6D70617261746F722D626C6F636B2D656E746974792E67 +65742D6F75747075742D7369676E616C01E7010168240140010473656C66E80100840104002D5B +6D6574686F645D636F6E647569742D626C6F636B2D656E746974792E6765742D626C6F636B2D65 +6E7469747901E9010168250140010473656C66EA010084010400395B6D6574686F645D636F7070 +65722D676F6C656D2D7374617475652D626C6F636B2D656E746974792E6765742D626C6F636B2D +656E7469747901EB010168260140010473656C66EC0100840104002D5B6D6574686F645D637261 +667465722D626C6F636B2D656E746974792E6765742D626C6F636B2D656E7469747901ED010140 +010473656C66EC0100F50004002A5B6D6574686F645D637261667465722D626C6F636B2D656E74 +6974792E6765742D636F6E7461696E657201EE010140010473656C66EC01007A0400395B6D6574 +686F645D637261667465722D626C6F636B2D656E746974792E6765742D6372616674696E672D74 +69636B732D72656D61696E696E6701EF010140010473656C66EC01007F0400295B6D6574686F64 +5D637261667465722D626C6F636B2D656E746974792E69732D74726967676572656401F0010168 +270140010473656C66F1010084010400345B6D6574686F645D637265616B696E672D6865617274 +2D626C6F636B2D656E746974792E6765742D626C6F636B2D656E7469747901F201014001047365 +6C66F10100BE010400355B6D6574686F645D637265616B696E672D68656172742D626C6F636B2D +656E746974792E6765742D637265616B696E672D7575696401F3010168280140010473656C66F4 +010084010400375B6D6574686F645D6461796C696768742D6465746563746F722D626C6F636B2D +656E746974792E6765742D626C6F636B2D656E7469747901F5010168290140010473656C66F601 +0084010400335B6D6574686F645D6465636F72617465642D706F742D626C6F636B2D656E746974 +792E6765742D626C6F636B2D656E7469747901F70101682A0140010473656C66F8010084010400 +2F5B6D6574686F645D64697370656E7365722D626C6F636B2D656E746974792E6765742D626C6F +636B2D656E7469747901F9010140010473656C66F80100F50004002C5B6D6574686F645D646973 +70656E7365722D626C6F636B2D656E746974792E6765742D636F6E7461696E657201FA0101682B +0140010473656C66FB0100840104002D5B6D6574686F645D64726F707065722D626C6F636B2D65 +6E746974792E6765742D626C6F636B2D656E7469747901FC010140010473656C66FB0100F50004 +002A5B6D6574686F645D64726F707065722D626C6F636B2D656E746974792E6765742D636F6E74 +61696E657201FD0101682C0140010473656C66FE010084010400365B6D6574686F645D656E6368 +616E74696E672D7461626C652D626C6F636B2D656E746974792E6765742D626C6F636B2D656E74 +69747901FF0101682D0140010473656C6680020084010400315B6D6574686F645D656E642D6761 +74657761792D626C6F636B2D656E746974792E6765742D626C6F636B2D656E7469747901810201 +40010473656C66800200780400285B6D6574686F645D656E642D676174657761792D626C6F636B +2D656E746974792E6765742D6167650182020140010473656C668002007F0400325B6D6574686F +645D656E642D676174657761792D626C6F636B2D656E746974792E69732D65786163742D74656C +65706F727401830201682E0140010473656C6684020084010400305B6D6574686F645D656E642D +706F7274616C2D626C6F636B2D656E746974792E6765742D626C6F636B2D656E74697479018502 +01682F0140010473656C6686020084010400315B6D6574686F645D656E6465722D63686573742D +626C6F636B2D656E746974792E6765742D626C6F636B2D656E746974790187020140010473656C +668602007904002D5B6D6574686F645D656E6465722D63686573742D626C6F636B2D656E746974 +792E7669657765722D636F756E740188020168300140010473656C66890200840104002D5B6D65 +74686F645D6675726E6163652D626C6F636B2D656E746974792E6765742D626C6F636B2D656E74 +697479018A020140010473656C66890200F50004002A5B6D6574686F645D6675726E6163652D62 +6C6F636B2D656E746974792E6765742D636F6E7461696E6572018B020140010473656C66890200 +7B0400335B6D6574686F645D6675726E6163652D626C6F636B2D656E746974792E6765742D636F +6F6B696E672D74696D652D7370656E74018C020400335B6D6574686F645D6675726E6163652D62 +6C6F636B2D656E746974792E6765742D636F6F6B696E672D746F74616C2D74696D65018C020400 +335B6D6574686F645D6675726E6163652D626C6F636B2D656E746974792E6765742D6C69742D74 +696D652D72656D61696E696E67018C0204002F5B6D6574686F645D6675726E6163652D626C6F63 +6B2D656E746974792E6765742D6C69742D746F74616C2D74696D65018C020140010473656C6689 +02007F0400275B6D6574686F645D6675726E6163652D626C6F636B2D656E746974792E69732D62 +75726E696E67018D020168310140010473656C668E0200840104002C5B6D6574686F645D686F70 +7065722D626C6F636B2D656E746974792E6765742D626C6F636B2D656E74697479018F02014001 +0473656C668E0200F5000400295B6D6574686F645D686F707065722D626C6F636B2D656E746974 +792E6765742D636F6E7461696E65720190020140010473656C668E02007A0400285B6D6574686F +645D686F707065722D626C6F636B2D656E746974792E6765742D636F6F6C646F776E0191020168 +320140010473656C66920200840104002C5B6D6574686F645D6A69677361772D626C6F636B2D65 +6E746974792E6765742D626C6F636B2D656E746974790193020140010473656C66920200730400 +245B6D6574686F645D6A69677361772D626C6F636B2D656E746974792E6765742D6E616D650194 +020400265B6D6574686F645D6A69677361772D626C6F636B2D656E746974792E6765742D746172 +6765740194020400245B6D6574686F645D6A69677361772D626C6F636B2D656E746974792E6765 +742D706F6F6C01940204002B5B6D6574686F645D6A69677361772D626C6F636B2D656E74697479 +2E6765742D66696E616C2D73746174650194020140010473656C669202007A0400325B6D657468 +6F645D6A69677361772D626C6F636B2D656E746974792E6765742D73656C656374696F6E2D7072 +696F726974790195020400325B6D6574686F645D6A69677361772D626C6F636B2D656E74697479 +2E6765742D706C6163656D656E742D7072696F726974790195020168330140010473656C669602 +00840104002D5B6D6574686F645D6C65637465726E2D626C6F636B2D656E746974792E6765742D +626C6F636B2D656E746974790197020140010473656C66960200F50004002A5B6D6574686F645D +6C65637465726E2D626C6F636B2D656E746974792E6765742D636F6E7461696E65720198020140 +010473656C66960200790400255B6D6574686F645D6C65637465726E2D626C6F636B2D656E7469 +74792E6765742D706167650199020168340140010473656C669A0200840104002C5B6D6574686F +645D706973746F6E2D626C6F636B2D656E746974792E6765742D626C6F636B2D656E7469747901 +9B020140010473656C669A0200760400285B6D6574686F645D706973746F6E2D626C6F636B2D65 +6E746974792E6765742D70726F6772657373019C020140010473656C669A02007F0400285B6D65 +74686F645D706973746F6E2D626C6F636B2D656E746974792E69732D657874656E64696E67019D +020400255B6D6574686F645D706973746F6E2D626C6F636B2D656E746974792E69732D736F7572 +6365019D020168350140010473656C669E020084010400335B6D6574686F645D706F74656E742D +73756C6675722D626C6F636B2D656E746974792E6765742D626C6F636B2D656E74697479019F02 +0168360140010473656C66A0020084010400345B6D6574686F645D7363756C6B2D636174616C79 +73742D626C6F636B2D656E746974792E6765742D626C6F636B2D656E7469747901A10201683701 +40010473656C66A2020084010400325B6D6574686F645D7363756C6B2D73656E736F722D626C6F +636B2D656E746974792E6765742D626C6F636B2D656E7469747901A3020168380140010473656C +66A4020084010400345B6D6574686F645D7363756C6B2D73687269656B65722D626C6F636B2D65 +6E746974792E6765742D626C6F636B2D656E7469747901A5020140010473656C66A402007A0400 +355B6D6574686F645D7363756C6B2D73687269656B65722D626C6F636B2D656E746974792E6765 +742D7761726E696E672D6C6576656C01A6020168390140010473656C66A70200840104002B5B6D +6574686F645D7368656C662D626C6F636B2D656E746974792E6765742D626C6F636B2D656E7469 +747901A8020140010473656C66A70200F5000400285B6D6574686F645D7368656C662D626C6F63 +6B2D656E746974792E6765742D636F6E7461696E657201A90201683A0140010473656C66AA0200 +84010400315B6D6574686F645D7368756C6B65722D626F782D626C6F636B2D656E746974792E67 +65742D626C6F636B2D656E7469747901AB020140010473656C66AA0200F50004002E5B6D657468 +6F645D7368756C6B65722D626F782D626C6F636B2D656E746974792E6765742D636F6E7461696E +657201AC020140010473656C66AA02007904002D5B6D6574686F645D7368756C6B65722D626F78 +2D626C6F636B2D656E746974792E7669657765722D636F756E7401AD0201683B0140010473656C +66AE0200840104002B5B6D6574686F645D736B756C6C2D626C6F636B2D656E746974792E676574 +2D626C6F636B2D656E7469747901AF020140010473656C66AE0200BE0104002F5B6D6574686F64 +5D736B756C6C2D626C6F636B2D656E746974792E6765742D6E6F74652D626C6F636B2D736F756E +6401B00201683C0140010473656C66B10200840104002C5B6D6574686F645D736D6F6B65722D62 +6C6F636B2D656E746974792E6765742D626C6F636B2D656E7469747901B2020140010473656C66 +B10200F5000400295B6D6574686F645D736D6F6B65722D626C6F636B2D656E746974792E676574 +2D636F6E7461696E657201B3020140010473656C66B102007B0400325B6D6574686F645D736D6F +6B65722D626C6F636B2D656E746974792E6765742D636F6F6B696E672D74696D652D7370656E74 +01B4020400325B6D6574686F645D736D6F6B65722D626C6F636B2D656E746974792E6765742D63 +6F6F6B696E672D746F74616C2D74696D6501B4020400325B6D6574686F645D736D6F6B65722D62 +6C6F636B2D656E746974792E6765742D6C69742D74696D652D72656D61696E696E6701B4020400 +2E5B6D6574686F645D736D6F6B65722D626C6F636B2D656E746974792E6765742D6C69742D746F +74616C2D74696D6501B4020140010473656C66B102007F0400265B6D6574686F645D736D6F6B65 +722D626C6F636B2D656E746974792E69732D6275726E696E6701B50201683D0140010473656C66 +B6020084010400355B6D6574686F645D7374727563747572652D626C6F636B2D626C6F636B2D65 +6E746974792E6765742D626C6F636B2D656E7469747901B7020140010473656C66B60200730400 +2D5B6D6574686F645D7374727563747572652D626C6F636B2D626C6F636B2D656E746974792E67 +65742D6E616D6501B80204002F5B6D6574686F645D7374727563747572652D626C6F636B2D626C +6F636B2D656E746974792E6765742D617574686F7201B80204002D5B6D6574686F645D73747275 +63747572652D626C6F636B2D626C6F636B2D656E746974792E6765742D6D6F646501B802014001 +0473656C66B60200760400325B6D6574686F645D7374727563747572652D626C6F636B2D626C6F +636B2D656E746974792E6765742D696E7465677269747901B9020140010473656C66B602007804 +002D5B6D6574686F645D7374727563747572652D626C6F636B2D626C6F636B2D656E746974792E +6765742D7365656401BA0201683E0140010473656C66BB020084010400305B6D6574686F645D74 +6573742D626C6F636B2D626C6F636B2D656E746974792E6765742D626C6F636B2D656E74697479 +01BC0201683F0140010473656C66BD020084010400395B6D6574686F645D746573742D696E7374 +616E63652D626C6F636B2D626C6F636B2D656E746974792E6765742D626C6F636B2D656E746974 +7901BE020168400140010473656C66BF020084010400335B6D6574686F645D747269616C2D7370 +61776E65722D626C6F636B2D656E746974792E6765742D626C6F636B2D656E7469747901C00201 +68410140010473656C66C10200840104002B5B6D6574686F645D7661756C742D626C6F636B2D65 +6E746974792E6765742D626C6F636B2D656E7469747901C20203002170756D706B696E3A706C75 +67696E2F626C6F636B2D656E7469747940302E312E30051D014202016D7D0E616E6772792D7669 +6C6C6167657205626C6F636B0C626C6F636B2D6D61726B657206627562626C650E73756C667572 +2D627562626C65730B6E6F78696F75732D676173116E6F78696F75732D6761732D636C6F756406 +6765797365720B6765797365722D626173650B6765797365722D706F6F660C6765797365722D70 +6C756D6505636C6F756411636F707065722D666972652D666C616D6504637269741064616D6167 +652D696E64696361746F720D647261676F6E2D6272656174680D6472697070696E672D6C617661 +0C66616C6C696E672D6C6176610C6C616E64696E672D6C6176610E6472697070696E672D776174 +65720D66616C6C696E672D7761746572046475737415647573742D636F6C6F722D7472616E7369 +74696F6E066566666563740E656C6465722D677561726469616E0D656E6368616E7465642D6869 +7407656E6368616E7407656E642D726F640D656E746974792D656666656374116578706C6F7369 +6F6E2D656D6974746572096578706C6F73696F6E04677573740A736D616C6C2D67757374126775 +73742D656D69747465722D6C6172676512677573742D656D69747465722D736D616C6C0A736F6E +69632D626F6F6D0C66616C6C696E672D647573740866697265776F726B0766697368696E670566 +6C616D6508696E6665737465640D6368657272792D6C65617665730F70616C652D6F616B2D6C65 +617665730D74696E7465642D6C65617665730A7363756C6B2D736F756C0C7363756C6B2D636861 +726765107363756C6B2D6368617267652D706F700F736F756C2D666972652D666C616D6504736F +756C05666C6173680E68617070792D76696C6C6167657209636F6D706F73746572056865617274 +0E696E7374616E742D656666656374046974656D09766962726174696F6E05747261696C107061 +7573652D6D6F622D67726F7774681072657365742D6D6F622D67726F7774680A6974656D2D736C +696D650B6974656D2D636F627765620D6974656D2D736E6F7762616C6C0B6C617267652D736D6F +6B65046C617661086D7963656C69756D046E6F746504706F6F6606706F7274616C047261696E05 +736D6F6B650B77686974652D736D6F6B6506736E65657A6504737069740973717569642D696E6B +0C73776565702D61747461636B10746F74656D2D6F662D756E6479696E670A756E646572776174 +65720673706C6173680577697463680A627562626C652D706F700C63757272656E742D646F776E +10627562626C652D636F6C756D6E2D7570086E617574696C757307646F6C7068696E1363616D70 +666972652D636F73792D736D6F6B651563616D70666972652D7369676E616C2D736D6F6B650E64 +72697070696E672D686F6E65790D66616C6C696E672D686F6E65790D6C616E64696E672D686F6E +65790E66616C6C696E672D6E65637461721566616C6C696E672D73706F72652D626C6F73736F6D +036173680D6372696D736F6E2D73706F72650C7761727065642D73706F72651173706F72652D62 +6C6F73736F6D2D616972166472697070696E672D6F6273696469616E2D746561721566616C6C69 +6E672D6F6273696469616E2D74656172156C616E64696E672D6F6273696469616E2D746561720E +726576657273652D706F7274616C0977686974652D6173680B736D616C6C2D666C616D6509736E +6F77666C616B65176472697070696E672D6472697073746F6E652D6C6176611666616C6C696E67 +2D6472697073746F6E652D6C617661186472697070696E672D6472697073746F6E652D77617465 +721766616C6C696E672D6472697073746F6E652D77617465720E676C6F772D73717569642D696E +6B04676C6F77067761782D6F6E077761782D6F66660E656C6563747269632D737061726B067363 +726170650673687269656B096567672D637261636B0A647573742D706C756D6517747269616C2D +737061776E65722D646574656374696F6E1F747269616C2D737061776E65722D64657465637469 +6F6E2D6F6D696E6F7573107661756C742D636F6E6E656374696F6E0B647573742D70696C6C6172 +106F6D696E6F75732D737061776E696E6709726169642D6F6D656E0A747269616C2D6F6D656E0D +626C6F636B2D6372756D626C650766697265666C790F73756C6675722D637562652D676F6F0400 +087061727469636C6503000003001E70756D706B696E3A706C7567696E2F7061727469636C6573 +40302E312E30051E014204016D0B066D6173746572056D75736963077265636F72647307776561 +7468657206626C6F636B7307686F7374696C65076E65757472616C07706C617965727307616D62 +69656E7405766F69636502756904000E736F756E642D63617465676F7279030000016DB00F1E65 +6E746974792D616C6C61792D616D6269656E742D776974682D6974656D21656E746974792D616C +6C61792D616D6269656E742D776974686F75742D6974656D12656E746974792D616C6C61792D64 +6561746811656E746974792D616C6C61792D6875727417656E746974792D616C6C61792D697465 +6D2D676976656E17656E746974792D616C6C61792D6974656D2D74616B656E18656E746974792D +616C6C61792D6974656D2D7468726F776E0C616D6269656E742D636176651F616D6269656E742D +626173616C742D64656C7461732D6164646974696F6E731A616D6269656E742D626173616C742D +64656C7461732D6C6F6F701A616D6269656E742D626173616C742D64656C7461732D6D6F6F6420 +616D6269656E742D6372696D736F6E2D666F726573742D6164646974696F6E731B616D6269656E +742D6372696D736F6E2D666F726573742D6C6F6F701B616D6269656E742D6372696D736F6E2D66 +6F726573742D6D6F6F641F616D6269656E742D6E65746865722D7761737465732D616464697469 +6F6E731A616D6269656E742D6E65746865722D7761737465732D6C6F6F701A616D6269656E742D +6E65746865722D7761737465732D6D6F6F6422616D6269656E742D736F756C2D73616E642D7661 +6C6C65792D6164646974696F6E731D616D6269656E742D736F756C2D73616E642D76616C6C6579 +2D6C6F6F701D616D6269656E742D736F756C2D73616E642D76616C6C65792D6D6F6F641F616D62 +69656E742D7761727065642D666F726573742D6164646974696F6E731A616D6269656E742D7761 +727065642D666F726573742D6C6F6F701A616D6269656E742D7761727065642D666F726573742D +6D6F6F6418616D6269656E742D756E64657277617465722D656E74657217616D6269656E742D75 +6E64657277617465722D6578697417616D6269656E742D756E64657277617465722D6C6F6F7021 +616D6269656E742D756E64657277617465722D6C6F6F702D6164646974696F6E7326616D626965 +6E742D756E64657277617465722D6C6F6F702D6164646974696F6E732D726172652C616D626965 +6E742D756E64657277617465722D6C6F6F702D6164646974696F6E732D756C7472612D72617265 +1A626C6F636B2D616D6574687973742D626C6F636B2D627265616B1A626C6F636B2D616D657468 +7973742D626C6F636B2D6368696D6519626C6F636B2D616D6574687973742D626C6F636B2D6661 +6C6C18626C6F636B2D616D6574687973742D626C6F636B2D6869741A626C6F636B2D616D657468 +7973742D626C6F636B2D706C6163651D626C6F636B2D616D6574687973742D626C6F636B2D7265 +736F6E61746519626C6F636B2D616D6574687973742D626C6F636B2D737465701C626C6F636B2D +616D6574687973742D636C75737465722D627265616B1B626C6F636B2D616D6574687973742D63 +6C75737465722D66616C6C1A626C6F636B2D616D6574687973742D636C75737465722D6869741C +626C6F636B2D616D6574687973742D636C75737465722D706C6163651B626C6F636B2D616D6574 +687973742D636C75737465722D737465701A626C6F636B2D616E6369656E742D6465627269732D +627265616B19626C6F636B2D616E6369656E742D6465627269732D737465701A626C6F636B2D61 +6E6369656E742D6465627269732D706C61636518626C6F636B2D616E6369656E742D6465627269 +732D68697419626C6F636B2D616E6369656E742D6465627269732D66616C6C11626C6F636B2D61 +6E76696C2D627265616B13626C6F636B2D616E76696C2D64657374726F7910626C6F636B2D616E +76696C2D66616C6C0F626C6F636B2D616E76696C2D68697410626C6F636B2D616E76696C2D6C61 +6E6411626C6F636B2D616E76696C2D706C61636510626C6F636B2D616E76696C2D737465700F62 +6C6F636B2D616E76696C2D75736514656E746974792D61726D6164696C6C6F2D65617415656E74 +6974792D61726D6164696C6C6F2D687572741D656E746974792D61726D6164696C6C6F2D687572 +742D7265647563656418656E746974792D61726D6164696C6C6F2D616D6269656E7415656E7469 +74792D61726D6164696C6C6F2D7374657016656E746974792D61726D6164696C6C6F2D64656174 +6815656E746974792D61726D6164696C6C6F2D726F6C6C15656E746974792D61726D6164696C6C +6F2D6C616E641B656E746974792D61726D6164696C6C6F2D73637574652D64726F701E656E7469 +74792D61726D6164696C6C6F2D756E726F6C6C2D66696E69736815656E746974792D61726D6164 +696C6C6F2D7065656B1D656E746974792D61726D6164696C6C6F2D756E726F6C6C2D7374617274 +16656E746974792D61726D6164696C6C6F2D6272757368166974656D2D61726D6F722D65717569 +702D636861696E186974656D2D61726D6F722D65717569702D6469616D6F6E64176974656D2D61 +726D6F722D65717569702D656C79747261186974656D2D61726D6F722D65717569702D67656E65 +726963156974656D2D61726D6F722D65717569702D676F6C64156974656D2D61726D6F722D6571 +7569702D69726F6E186974656D2D61726D6F722D65717569702D6C656174686572176974656D2D +61726D6F722D65717569702D636F707065721A6974656D2D61726D6F722D65717569702D6E6574 +686572697465176974656D2D61726D6F722D65717569702D747572746C65156974656D2D61726D +6F722D65717569702D776F6C66176974656D2D61726D6F722D756E65717569702D776F6C661969 +74656D2D61726D6F722D65717569702D6E617574696C75731B6974656D2D61726D6F722D756E65 +717569702D6E617574696C757318656E746974792D61726D6F722D7374616E642D627265616B17 +656E746974792D61726D6F722D7374616E642D66616C6C16656E746974792D61726D6F722D7374 +616E642D68697418656E746974792D61726D6F722D7374616E642D706C61636510656E74697479 +2D6172726F772D68697417656E746974792D6172726F772D6869742D706C6179657212656E7469 +74792D6172726F772D73686F6F740E6974656D2D6178652D73747269700F6974656D2D6178652D +736372617065106974656D2D6178652D7761782D6F666615656E746974792D61786F6C6F746C2D +61747461636B14656E746974792D61786F6C6F746C2D646561746813656E746974792D61786F6C +6F746C2D6875727417656E746974792D61786F6C6F746C2D69646C652D61697219656E74697479 +2D61786F6C6F746C2D69646C652D776174657215656E746974792D61786F6C6F746C2D73706C61 +736813656E746974792D61786F6C6F746C2D7377696D12626C6F636B2D617A616C65612D627265 +616B11626C6F636B2D617A616C65612D66616C6C10626C6F636B2D617A616C65612D6869741262 +6C6F636B2D617A616C65612D706C61636511626C6F636B2D617A616C65612D7374657019626C6F +636B2D617A616C65612D6C65617665732D627265616B18626C6F636B2D617A616C65612D6C6561 +7665732D66616C6C17626C6F636B2D617A616C65612D6C65617665732D68697419626C6F636B2D +617A616C65612D6C65617665732D706C61636518626C6F636B2D617A616C65612D6C6561766573 +2D737465701C656E746974792D626162792D6E617574696C75732D616D6269656E7421656E7469 +74792D626162792D6E617574696C75732D616D6269656E742D6C616E641A656E746974792D6261 +62792D6E617574696C75732D64656174681F656E746974792D626162792D6E617574696C75732D +64656174682D6C616E6418656E746974792D626162792D6E617574696C75732D65617419656E74 +6974792D626162792D6E617574696C75732D687572741E656E746974792D626162792D6E617574 +696C75732D687572742D6C616E6416656E746974792D6E617574696C75732D726964696E671965 +6E746974792D626162792D6E617574696C75732D7377696D12626C6F636B2D62616D626F6F2D62 +7265616B11626C6F636B2D62616D626F6F2D66616C6C10626C6F636B2D62616D626F6F2D686974 +12626C6F636B2D62616D626F6F2D706C61636511626C6F636B2D62616D626F6F2D737465701A62 +6C6F636B2D62616D626F6F2D7361706C696E672D627265616B18626C6F636B2D62616D626F6F2D +7361706C696E672D6869741A626C6F636B2D62616D626F6F2D7361706C696E672D706C61636517 +626C6F636B2D62616D626F6F2D776F6F642D627265616B16626C6F636B2D62616D626F6F2D776F +6F642D66616C6C15626C6F636B2D62616D626F6F2D776F6F642D68697417626C6F636B2D62616D +626F6F2D776F6F642D706C61636516626C6F636B2D62616D626F6F2D776F6F642D737465701C62 +6C6F636B2D62616D626F6F2D776F6F642D646F6F722D636C6F73651B626C6F636B2D62616D626F +6F2D776F6F642D646F6F722D6F70656E20626C6F636B2D62616D626F6F2D776F6F642D74726170 +646F6F722D636C6F73651F626C6F636B2D62616D626F6F2D776F6F642D74726170646F6F722D6F +70656E22626C6F636B2D62616D626F6F2D776F6F642D627574746F6E2D636C69636B2D6F666621 +626C6F636B2D62616D626F6F2D776F6F642D627574746F6E2D636C69636B2D6F6E2A626C6F636B +2D62616D626F6F2D776F6F642D70726573737572652D706C6174652D636C69636B2D6F66662962 +6C6F636B2D62616D626F6F2D776F6F642D70726573737572652D706C6174652D636C69636B2D6F +6E22626C6F636B2D62616D626F6F2D776F6F642D66656E63652D676174652D636C6F736521626C +6F636B2D62616D626F6F2D776F6F642D66656E63652D676174652D6F70656E12626C6F636B2D62 +617272656C2D636C6F736511626C6F636B2D62617272656C2D6F70656E12626C6F636B2D626173 +616C742D627265616B11626C6F636B2D626173616C742D7374657012626C6F636B2D626173616C +742D706C61636510626C6F636B2D626173616C742D68697411626C6F636B2D626173616C742D66 +616C6C12656E746974792D6261742D616D6269656E7410656E746974792D6261742D6465617468 +0F656E746974792D6261742D687572740F656E746974792D6261742D6C6F6F7012656E74697479 +2D6261742D74616B656F666615626C6F636B2D626561636F6E2D616374697661746514626C6F63 +6B2D626561636F6E2D616D6269656E7417626C6F636B2D626561636F6E2D646561637469766174 +6519626C6F636B2D626561636F6E2D706F7765722D73656C65637410656E746974792D6265652D +64656174680F656E746974792D6265652D687572741A656E746974792D6265652D6C6F6F702D61 +6767726573736976650F656E746974792D6265652D6C6F6F7010656E746974792D6265652D7374 +696E6714656E746974792D6265652D706F6C6C696E61746512626C6F636B2D626565686976652D +6472697013626C6F636B2D626565686976652D656E74657212626C6F636B2D626565686976652D +6578697413626C6F636B2D626565686976652D736865617212626C6F636B2D626565686976652D +776F726B0E626C6F636B2D62656C6C2D75736513626C6F636B2D62656C6C2D7265736F6E617465 +18626C6F636B2D6269672D647269706C6561662D627265616B17626C6F636B2D6269672D647269 +706C6561662D66616C6C16626C6F636B2D6269672D647269706C6561662D68697418626C6F636B +2D6269672D647269706C6561662D706C61636517626C6F636B2D6269672D647269706C6561662D +7374657014656E746974792D626C617A652D616D6269656E7411656E746974792D626C617A652D +6275726E12656E746974792D626C617A652D646561746811656E746974792D626C617A652D6875 +727412656E746974792D626C617A652D73686F6F7417656E746974792D626F61742D706164646C +652D6C616E6418656E746974792D626F61742D706164646C652D776174657215656E746974792D +626F676765642D616D6269656E7413656E746974792D626F676765642D646561746812656E7469 +74792D626F676765642D6875727413656E746974792D626F676765642D736865617212656E7469 +74792D626F676765642D7374657016626C6F636B2D626F6E652D626C6F636B2D627265616B1562 +6C6F636B2D626F6E652D626C6F636B2D66616C6C14626C6F636B2D626F6E652D626C6F636B2D68 +697416626C6F636B2D626F6E652D626C6F636B2D706C61636515626C6F636B2D626F6E652D626C +6F636B2D73746570126974656D2D626F6E652D6D65616C2D757365136974656D2D626F6F6B2D70 +6167652D7475726E0D6974656D2D626F6F6B2D7075741F626C6F636B2D626C6173746675726E61 +63652D666972652D637261636B6C65116974656D2D626F74746C652D656D707479106974656D2D +626F74746C652D66696C6C1D6974656D2D626F74746C652D66696C6C2D647261676F6E62726561 +746814656E746974792D627265657A652D63686172676515656E746974792D627265657A652D64 +65666C65637414656E746974792D627265657A652D696E68616C6519656E746974792D62726565 +7A652D69646C652D67726F756E6416656E746974792D627265657A652D69646C652D6169721365 +6E746974792D627265657A652D73686F6F7412656E746974792D627265657A652D6A756D701265 +6E746974792D627265657A652D6C616E6413656E746974792D627265657A652D736C6964651365 +6E746974792D627265657A652D646561746812656E746974792D627265657A652D687572741365 +6E746974792D627265657A652D776869726C18656E746974792D627265657A652D77696E642D62 +7572737418626C6F636B2D62726577696E672D7374616E642D627265771B6974656D2D62727573 +682D6272757368696E672D67656E65726963186974656D2D62727573682D6272757368696E672D +73616E641A6974656D2D62727573682D6272757368696E672D67726176656C216974656D2D6272 +7573682D6272757368696E672D73616E642D636F6D706C657465236974656D2D62727573682D62 +72757368696E672D67726176656C2D636F6D706C6574651E626C6F636B2D627562626C652D636F +6C756D6E2D627562626C652D706F7023626C6F636B2D627562626C652D636F6C756D6E2D757077 +617264732D616D6269656E7422626C6F636B2D627562626C652D636F6C756D6E2D757077617264 +732D696E7369646525626C6F636B2D627562626C652D636F6C756D6E2D776869726C706F6F6C2D +616D6269656E7424626C6F636B2D627562626C652D636F6C756D6E2D776869726C706F6F6C2D69 +6E736964651175692D6875642D627562626C652D706F70116974656D2D6275636B65742D656D70 +7479196974656D2D6275636B65742D656D7074792D61786F6C6F746C166974656D2D6275636B65 +742D656D7074792D66697368166974656D2D6275636B65742D656D7074792D6C6176611D697465 +6D2D6275636B65742D656D7074792D706F776465722D736E6F771D6974656D2D6275636B65742D +656D7074792D73756C6675722D63756265196974656D2D6275636B65742D656D7074792D746164 +706F6C65106974656D2D6275636B65742D66696C6C186974656D2D6275636B65742D66696C6C2D +61786F6C6F746C156974656D2D6275636B65742D66696C6C2D66697368156974656D2D6275636B +65742D66696C6C2D6C6176611C6974656D2D6275636B65742D66696C6C2D706F776465722D736E +6F771C6974656D2D6275636B65742D66696C6C2D73756C6675722D63756265186974656D2D6275 +636B65742D66696C6C2D746164706F6C65196974656D2D62756E646C652D64726F702D636F6E74 +656E7473126974656D2D62756E646C652D696E73657274176974656D2D62756E646C652D696E73 +6572742D6661696C166974656D2D62756E646C652D72656D6F76652D6F6E6519626C6F636B2D63 +61637475732D666C6F7765722D627265616B19626C6F636B2D6361637475732D666C6F7765722D +706C61636515626C6F636B2D63616B652D6164642D63616E646C6513626C6F636B2D63616C6369 +74652D627265616B12626C6F636B2D63616C636974652D7374657013626C6F636B2D63616C6369 +74652D706C61636511626C6F636B2D63616C636974652D68697412626C6F636B2D63616C636974 +652D66616C6C19656E746974792D63616D656C2D6875736B2D616D6269656E7416656E74697479 +2D63616D656C2D6875736B2D646173681C656E746974792D63616D656C2D6875736B2D64617368 +2D726561647917656E746974792D63616D656C2D6875736B2D646561746815656E746974792D63 +616D656C2D6875736B2D65617416656E746974792D63616D656C2D6875736B2D6875727418656E +746974792D63616D656C2D6875736B2D736164646C6515656E746974792D63616D656C2D687573 +6B2D73697417656E746974792D63616D656C2D6875736B2D7374616E6416656E746974792D6361 +6D656C2D6875736B2D737465701B656E746974792D63616D656C2D6875736B2D737465702D7361 +6E6414656E746974792D63616D656C2D616D6269656E7411656E746974792D63616D656C2D6461 +736817656E746974792D63616D656C2D646173682D726561647912656E746974792D63616D656C +2D646561746810656E746974792D63616D656C2D65617411656E746974792D63616D656C2D6875 +727413656E746974792D63616D656C2D736164646C6510656E746974792D63616D656C2D736974 +12656E746974792D63616D656C2D7374616E6411656E746974792D63616D656C2D737465701665 +6E746974792D63616D656C2D737465702D73616E6416626C6F636B2D63616D70666972652D6372 +61636B6C6514626C6F636B2D63616E646C652D616D6269656E7412626C6F636B2D63616E646C65 +2D627265616B17626C6F636B2D63616E646C652D657874696E677569736811626C6F636B2D6361 +6E646C652D66616C6C10626C6F636B2D63616E646C652D68697412626C6F636B2D63616E646C65 +2D706C61636511626C6F636B2D63616E646C652D7374657017656E746974792D626162792D6361 +742D616D6269656E741D656E746974792D626162792D6361742D73747261792D616D6269656E74 +15656E746974792D626162792D6361742D646561746813656E746974792D626162792D6361742D +65617414656E746974792D626162792D6361742D686973731C656E746974792D626162792D6361 +742D6265672D666F722D666F6F6414656E746974792D626162792D6361742D6875727414656E74 +6974792D626162792D6361742D7075727217656E746974792D626162792D6361742D7075727265 +6F7712656E746974792D6361742D616D6269656E7418656E746974792D6361742D73747261792D +616D6269656E740F656E746974792D6361742D686973730F656E746974792D6361742D68757274 +10656E746974792D6361742D64656174680E656E746974792D6361742D65617417656E74697479 +2D6361742D6265672D666F722D666F6F640F656E746974792D6361742D7075727212656E746974 +792D6361742D70757272656F7718656E746974792D6361742D726F79616C2D616D6269656E741E +656E746974792D6361742D726F79616C2D73747261792D616D6269656E7415656E746974792D63 +61742D726F79616C2D6869737315656E746974792D6361742D726F79616C2D6875727416656E74 +6974792D6361742D726F79616C2D646561746814656E746974792D6361742D726F79616C2D6561 +741D656E746974792D6361742D726F79616C2D6265672D666F722D666F6F6415656E746974792D +6361742D726F79616C2D7075727218656E746974792D6361742D726F79616C2D70757272656F77 +16626C6F636B2D636176652D76696E65732D627265616B15626C6F636B2D636176652D76696E65 +732D66616C6C14626C6F636B2D636176652D76696E65732D68697416626C6F636B2D636176652D +76696E65732D706C61636515626C6F636B2D636176652D76696E65732D737465701D626C6F636B +2D636176652D76696E65732D7069636B2D6265727269657311626C6F636B2D636861696E2D6272 +65616B10626C6F636B2D636861696E2D66616C6C0F626C6F636B2D636861696E2D68697411626C +6F636B2D636861696E2D706C61636510626C6F636B2D636861696E2D7374657017626C6F636B2D +6368657272792D776F6F642D627265616B16626C6F636B2D6368657272792D776F6F642D66616C +6C15626C6F636B2D6368657272792D776F6F642D68697417626C6F636B2D6368657272792D776F +6F642D706C61636516626C6F636B2D6368657272792D776F6F642D737465701A626C6F636B2D63 +68657272792D7361706C696E672D627265616B19626C6F636B2D6368657272792D7361706C696E +672D66616C6C18626C6F636B2D6368657272792D7361706C696E672D6869741A626C6F636B2D63 +68657272792D7361706C696E672D706C61636519626C6F636B2D6368657272792D7361706C696E +672D7374657019626C6F636B2D6368657272792D6C65617665732D627265616B18626C6F636B2D +6368657272792D6C65617665732D66616C6C17626C6F636B2D6368657272792D6C65617665732D +68697419626C6F636B2D6368657272792D6C65617665732D706C61636518626C6F636B2D636865 +7272792D6C65617665732D7374657023626C6F636B2D6368657272792D776F6F642D68616E6769 +6E672D7369676E2D7374657024626C6F636B2D6368657272792D776F6F642D68616E67696E672D +7369676E2D627265616B23626C6F636B2D6368657272792D776F6F642D68616E67696E672D7369 +676E2D66616C6C22626C6F636B2D6368657272792D776F6F642D68616E67696E672D7369676E2D +68697424626C6F636B2D6368657272792D776F6F642D68616E67696E672D7369676E2D706C6163 +651C626C6F636B2D6368657272792D776F6F642D646F6F722D636C6F73651B626C6F636B2D6368 +657272792D776F6F642D646F6F722D6F70656E20626C6F636B2D6368657272792D776F6F642D74 +726170646F6F722D636C6F73651F626C6F636B2D6368657272792D776F6F642D74726170646F6F +722D6F70656E22626C6F636B2D6368657272792D776F6F642D627574746F6E2D636C69636B2D6F +666621626C6F636B2D6368657272792D776F6F642D627574746F6E2D636C69636B2D6F6E2A626C +6F636B2D6368657272792D776F6F642D70726573737572652D706C6174652D636C69636B2D6F66 +6629626C6F636B2D6368657272792D776F6F642D70726573737572652D706C6174652D636C6963 +6B2D6F6E22626C6F636B2D6368657272792D776F6F642D66656E63652D676174652D636C6F7365 +21626C6F636B2D6368657272792D776F6F642D66656E63652D676174652D6F70656E11626C6F63 +6B2D63686573742D636C6F736512626C6F636B2D63686573742D6C6F636B656410626C6F636B2D +63686573742D6F70656E1B656E746974792D626162792D636869636B656E2D616D6269656E7419 +656E746974792D626162792D636869636B656E2D646561746812656E746974792D636869636B65 +6E2D65676718656E746974792D626162792D636869636B656E2D6875727413656E746974792D63 +6869636B656E2D7374657018656E746974792D626162792D636869636B656E2D7374657016656E +746974792D636869636B656E2D616D6269656E7413656E746974792D636869636B656E2D687572 +7414656E746974792D636869636B656E2D64656174681C656E746974792D636869636B656E2D70 +69636B792D616D6269656E7419656E746974792D636869636B656E2D7069636B792D687572741A +656E746974792D636869636B656E2D7069636B792D64656174681E626C6F636B2D63686973656C +65642D626F6F6B7368656C662D627265616B1D626C6F636B2D63686973656C65642D626F6F6B73 +68656C662D66616C6C1C626C6F636B2D63686973656C65642D626F6F6B7368656C662D6869741F +626C6F636B2D63686973656C65642D626F6F6B7368656C662D696E7365727429626C6F636B2D63 +686973656C65642D626F6F6B7368656C662D696E736572742D656E6368616E7465641D626C6F63 +6B2D63686973656C65642D626F6F6B7368656C662D737465701F626C6F636B2D63686973656C65 +642D626F6F6B7368656C662D7069636B757029626C6F636B2D63686973656C65642D626F6F6B73 +68656C662D7069636B75702D656E6368616E7465641E626C6F636B2D63686973656C65642D626F +6F6B7368656C662D706C61636519626C6F636B2D63686F7275732D666C6F7765722D6465617468 +18626C6F636B2D63686F7275732D666C6F7765722D67726F771A6974656D2D63686F7275732D66 +727569742D74656C65706F727412626C6F636B2D636F627765622D627265616B11626C6F636B2D +636F627765622D7374657012626C6F636B2D636F627765622D706C61636510626C6F636B2D636F +627765622D68697411626C6F636B2D636F627765622D66616C6C12656E746974792D636F642D61 +6D6269656E7410656E746974792D636F642D64656174680F656E746974792D636F642D666C6F70 +0F656E746974792D636F642D6875727416626C6F636B2D636F6D70617261746F722D636C69636B +15626C6F636B2D636F6D706F737465722D656D70747914626C6F636B2D636F6D706F737465722D +66696C6C1C626C6F636B2D636F6D706F737465722D66696C6C2D7375636365737315626C6F636B +2D636F6D706F737465722D726561647916626C6F636B2D636F6E647569742D6163746976617465 +15626C6F636B2D636F6E647569742D616D6269656E741B626C6F636B2D636F6E647569742D616D +6269656E742D73686F72741B626C6F636B2D636F6E647569742D61747461636B2D746172676574 +18626C6F636B2D636F6E647569742D6465616374697661746517626C6F636B2D636F707065722D +62756C622D627265616B16626C6F636B2D636F707065722D62756C622D7374657017626C6F636B +2D636F707065722D62756C622D706C61636515626C6F636B2D636F707065722D62756C622D6869 +7416626C6F636B2D636F707065722D62756C622D66616C6C19626C6F636B2D636F707065722D62 +756C622D7475726E2D6F6E1A626C6F636B2D636F707065722D62756C622D7475726E2D6F666612 +626C6F636B2D636F707065722D627265616B11626C6F636B2D636F707065722D7374657012626C +6F636B2D636F707065722D706C61636510626C6F636B2D636F707065722D68697411626C6F636B +2D636F707065722D66616C6C18626C6F636B2D636F707065722D63686573742D636C6F73651762 +6C6F636B2D636F707065722D63686573742D6F70656E22626C6F636B2D636F707065722D636865 +73742D7765617468657265642D636C6F736521626C6F636B2D636F707065722D63686573742D77 +65617468657265642D6F70656E21626C6F636B2D636F707065722D63686573742D6F786964697A +65642D636C6F736520626C6F636B2D636F707065722D63686573742D6F786964697A65642D6F70 +656E17626C6F636B2D636F707065722D646F6F722D636C6F736516626C6F636B2D636F70706572 +2D646F6F722D6F70656E18656E746974792D636F707065722D676F6C656D2D7374657018656E74 +6974792D636F707065722D676F6C656D2D6875727419656E746974792D636F707065722D676F6C +656D2D646561746822656E746974792D636F707065722D676F6C656D2D7765617468657265642D +7374657022656E746974792D636F707065722D676F6C656D2D7765617468657265642D68757274 +23656E746974792D636F707065722D676F6C656D2D7765617468657265642D646561746821656E +746974792D636F707065722D676F6C656D2D6F786964697A65642D7374657021656E746974792D +636F707065722D676F6C656D2D6F786964697A65642D6875727422656E746974792D636F707065 +722D676F6C656D2D6F786964697A65642D646561746818656E746974792D636F707065722D676F +6C656D2D7370696E22656E746974792D636F707065722D676F6C656D2D7765617468657265642D +7370696E21656E746974792D636F707065722D676F6C656D2D6F786964697A65642D7370696E1F +656E746974792D636F707065722D676F6C656D2D6E6F2D6974656D2D67657422656E746974792D +636F707065722D676F6C656D2D6E6F2D6974656D2D6E6F2D6765741D656E746974792D636F7070 +65722D676F6C656D2D6974656D2D64726F7020656E746974792D636F707065722D676F6C656D2D +6974656D2D6E6F2D64726F7021656E746974792D636F707065722D676F6C656D2D6265636F6D65 +2D7374617475651F626C6F636B2D636F707065722D676F6C656D2D7374617475652D627265616B +1F626C6F636B2D636F707065722D676F6C656D2D7374617475652D706C6163651D626C6F636B2D +636F707065722D676F6C656D2D7374617475652D6869741E626C6F636B2D636F707065722D676F +6C656D2D7374617475652D737465701E626C6F636B2D636F707065722D676F6C656D2D73746174 +75652D66616C6C19656E746974792D636F707065722D676F6C656D2D737061776E19656E746974 +792D636F707065722D676F6C656D2D736865617218626C6F636B2D636F707065722D6772617465 +2D627265616B17626C6F636B2D636F707065722D67726174652D7374657018626C6F636B2D636F +707065722D67726174652D706C61636516626C6F636B2D636F707065722D67726174652D686974 +17626C6F636B2D636F707065722D67726174652D66616C6C1B626C6F636B2D636F707065722D74 +726170646F6F722D636C6F73651A626C6F636B2D636F707065722D74726170646F6F722D6F7065 +6E17626C6F636B2D636F72616C2D626C6F636B2D627265616B16626C6F636B2D636F72616C2D62 +6C6F636B2D66616C6C15626C6F636B2D636F72616C2D626C6F636B2D68697417626C6F636B2D63 +6F72616C2D626C6F636B2D706C61636516626C6F636B2D636F72616C2D626C6F636B2D73746570 +0F656E746974792D636F772D6D696C6B12656E746974792D636F772D616D6269656E740F656E74 +6974792D636F772D6875727410656E746974792D636F772D64656174680F656E746974792D636F +772D7374657018656E746974792D636F772D6D6F6F64792D616D6269656E7415656E746974792D +636F772D6D6F6F64792D6875727416656E746974792D636F772D6D6F6F64792D64656174681565 +6E746974792D636F772D6D6F6F64792D7374657013626C6F636B2D637261667465722D63726166 +7412626C6F636B2D637261667465722D6661696C17656E746974792D637265616B696E672D616D +6269656E7418656E746974792D637265616B696E672D61637469766174651A656E746974792D63 +7265616B696E672D6465616374697661746516656E746974792D637265616B696E672D61747461 +636B15656E746974792D637265616B696E672D646561746814656E746974792D637265616B696E +672D7374657016656E746974792D637265616B696E672D667265657A6518656E746974792D6372 +65616B696E672D756E667265657A6515656E746974792D637265616B696E672D737061776E1465 +6E746974792D637265616B696E672D7377617916656E746974792D637265616B696E672D747769 +7463681A626C6F636B2D637265616B696E672D68656172742D627265616B19626C6F636B2D6372 +65616B696E672D68656172742D66616C6C18626C6F636B2D637265616B696E672D68656172742D +68697419626C6F636B2D637265616B696E672D68656172742D687572741A626C6F636B2D637265 +616B696E672D68656172742D706C61636519626C6F636B2D637265616B696E672D68656172742D +7374657019626C6F636B2D637265616B696E672D68656172742D69646C651A626C6F636B2D6372 +65616B696E672D68656172742D737061776E14656E746974792D637265657065722D6465617468 +13656E746974792D637265657065722D6875727415656E746974792D637265657065722D707269 +6D656410626C6F636B2D63726F702D627265616B0F6974656D2D63726F702D706C616E74116974 +656D2D63726F7373626F772D686974196974656D2D63726F7373626F772D6C6F6164696E672D65 +6E641C6974656D2D63726F7373626F772D6C6F6164696E672D6D6964646C651B6974656D2D6372 +6F7373626F772D6C6F6164696E672D73746172741C6974656D2D63726F7373626F772D71756963 +6B2D6368617267652D311C6974656D2D63726F7373626F772D717569636B2D6368617267652D32 +1C6974656D2D63726F7373626F772D717569636B2D6368617267652D33136974656D2D63726F73 +73626F772D73686F6F7413626C6F636B2D64656164627573682D69646C6519626C6F636B2D6465 +636F72617465642D706F742D627265616B18626C6F636B2D6465636F72617465642D706F742D66 +616C6C17626C6F636B2D6465636F72617465642D706F742D6869741A626C6F636B2D6465636F72 +617465642D706F742D696E736572741F626C6F636B2D6465636F72617465642D706F742D696E73 +6572742D6661696C18626C6F636B2D6465636F72617465642D706F742D7374657019626C6F636B +2D6465636F72617465642D706F742D706C6163651B626C6F636B2D6465636F72617465642D706F +742D736861747465721C626C6F636B2D64656570736C6174652D627269636B732D627265616B1B +626C6F636B2D64656570736C6174652D627269636B732D66616C6C1A626C6F636B2D6465657073 +6C6174652D627269636B732D6869741C626C6F636B2D64656570736C6174652D627269636B732D +706C6163651B626C6F636B2D64656570736C6174652D627269636B732D7374657015626C6F636B +2D64656570736C6174652D627265616B14626C6F636B2D64656570736C6174652D66616C6C1362 +6C6F636B2D64656570736C6174652D68697415626C6F636B2D64656570736C6174652D706C6163 +6514626C6F636B2D64656570736C6174652D737465701B626C6F636B2D64656570736C6174652D +74696C65732D627265616B1A626C6F636B2D64656570736C6174652D74696C65732D66616C6C19 +626C6F636B2D64656570736C6174652D74696C65732D6869741B626C6F636B2D64656570736C61 +74652D74696C65732D706C6163651A626C6F636B2D64656570736C6174652D74696C65732D7374 +657018626C6F636B2D64697370656E7365722D64697370656E736514626C6F636B2D6469737065 +6E7365722D6661696C16626C6F636B2D64697370656E7365722D6C61756E636816656E74697479 +2D646F6C7068696E2D616D6269656E741C656E746974792D646F6C7068696E2D616D6269656E74 +2D776174657215656E746974792D646F6C7068696E2D61747461636B14656E746974792D646F6C +7068696E2D646561746812656E746974792D646F6C7068696E2D65617413656E746974792D646F +6C7068696E2D6875727413656E746974792D646F6C7068696E2D6A756D7013656E746974792D64 +6F6C7068696E2D706C617915656E746974792D646F6C7068696E2D73706C61736813656E746974 +792D646F6C7068696E2D7377696D15656E746974792D646F6E6B65792D616D6269656E7413656E +746974792D646F6E6B65792D616E67727913656E746974792D646F6E6B65792D63686573741365 +6E746974792D646F6E6B65792D646561746811656E746974792D646F6E6B65792D65617412656E +746974792D646F6E6B65792D6875727412656E746974792D646F6E6B65792D6A756D7017626C6F +636B2D64726965642D67686173742D627265616B16626C6F636B2D64726965642D67686173742D +7374657016626C6F636B2D64726965642D67686173742D66616C6C19626C6F636B2D6472696564 +2D67686173742D616D6269656E741F626C6F636B2D64726965642D67686173742D616D6269656E +742D776174657217626C6F636B2D64726965642D67686173742D706C61636520626C6F636B2D64 +726965642D67686173742D706C6163652D696E2D77617465721C626C6F636B2D64726965642D67 +686173742D7472616E736974696F6E1B626C6F636B2D6472697073746F6E652D626C6F636B2D62 +7265616B1A626C6F636B2D6472697073746F6E652D626C6F636B2D737465701B626C6F636B2D64 +72697073746F6E652D626C6F636B2D706C61636519626C6F636B2D6472697073746F6E652D626C +6F636B2D6869741A626C6F636B2D6472697073746F6E652D626C6F636B2D66616C6C17626C6F63 +6B2D6472792D67726173732D616D6269656E741D626C6F636B2D706F696E7465642D6472697073 +746F6E652D627265616B1C626C6F636B2D706F696E7465642D6472697073746F6E652D73746570 +1D626C6F636B2D706F696E7465642D6472697073746F6E652D706C6163651B626C6F636B2D706F +696E7465642D6472697073746F6E652D6869741C626C6F636B2D706F696E7465642D6472697073 +746F6E652D66616C6C1C626C6F636B2D706F696E7465642D6472697073746F6E652D6C616E6421 +626C6F636B2D706F696E7465642D6472697073746F6E652D647269702D6C61766122626C6F636B +2D706F696E7465642D6472697073746F6E652D647269702D77617465722F626C6F636B2D706F69 +6E7465642D6472697073746F6E652D647269702D6C6176612D696E746F2D6361756C64726F6E30 +626C6F636B2D706F696E7465642D6472697073746F6E652D647269702D77617465722D696E746F +2D6361756C64726F6E1C626C6F636B2D6269672D647269706C6561662D74696C742D646F776E1A +626C6F636B2D6269672D647269706C6561662D74696C742D757016656E746974792D64726F776E +65642D616D6269656E741C656E746974792D64726F776E65642D616D6269656E742D7761746572 +14656E746974792D64726F776E65642D64656174681A656E746974792D64726F776E65642D6465 +6174682D776174657213656E746974792D64726F776E65642D6875727419656E746974792D6472 +6F776E65642D687572742D776174657214656E746974792D64726F776E65642D73686F6F741365 +6E746974792D64726F776E65642D7374657013656E746974792D64726F776E65642D7377696D0C +6974656D2D6479652D75736510656E746974792D6567672D7468726F771D656E746974792D656C +6465722D677561726469616E2D616D6269656E7422656E746974792D656C6465722D6775617264 +69616E2D616D6269656E742D6C616E641B656E746974792D656C6465722D677561726469616E2D +63757273651B656E746974792D656C6465722D677561726469616E2D646561746820656E746974 +792D656C6465722D677561726469616E2D64656174682D6C616E641A656E746974792D656C6465 +722D677561726469616E2D666C6F701A656E746974792D656C6465722D677561726469616E2D68 +7572741F656E746974792D656C6465722D677561726469616E2D687572742D6C616E6412697465 +6D2D656C797472612D666C79696E671B626C6F636B2D656E6368616E746D656E742D7461626C65 +2D75736517626C6F636B2D656E6465722D63686573742D636C6F736516626C6F636B2D656E6465 +722D63686573742D6F70656E1B656E746974792D656E6465722D647261676F6E2D616D6269656E +7419656E746974792D656E6465722D647261676F6E2D64656174681E656E746974792D64726167 +6F6E2D6669726562616C6C2D6578706C6F646518656E746974792D656E6465722D647261676F6E +2D666C617019656E746974792D656E6465722D647261676F6E2D67726F776C18656E746974792D +656E6465722D647261676F6E2D6875727419656E746974792D656E6465722D647261676F6E2D73 +686F6F7416656E746974792D656E6465722D6579652D646561746817656E746974792D656E6465 +722D6579652D6C61756E636817656E746974792D656E6465726D616E2D616D6269656E7415656E +746974792D656E6465726D616E2D646561746814656E746974792D656E6465726D616E2D687572 +7416656E746974792D656E6465726D616E2D73637265616D15656E746974792D656E6465726D61 +6E2D737461726518656E746974792D656E6465726D616E2D74656C65706F727418656E74697479 +2D656E6465726D6974652D616D6269656E7416656E746974792D656E6465726D6974652D646561 +746815656E746974792D656E6465726D6974652D6875727415656E746974792D656E6465726D69 +74652D7374657018656E746974792D656E6465722D706561726C2D7468726F7717626C6F636B2D +656E642D676174657761792D737061776E1B626C6F636B2D656E642D706F7274616C2D6672616D +652D66696C6C16626C6F636B2D656E642D706F7274616C2D737061776E15656E746974792D6576 +6F6B65722D616D6269656E7418656E746974792D65766F6B65722D636173742D7370656C6C1765 +6E746974792D65766F6B65722D63656C65627261746513656E746974792D65766F6B65722D6465 +6174681A656E746974792D65766F6B65722D66616E67732D61747461636B12656E746974792D65 +766F6B65722D687572741C656E746974792D65766F6B65722D707265706172652D61747461636B +1C656E746974792D65766F6B65722D707265706172652D73756D6D6F6E1C656E746974792D6576 +6F6B65722D707265706172652D776F6C6F6C6F1E656E746974792D657870657269656E63652D62 +6F74746C652D7468726F771C656E746974792D657870657269656E63652D6F72622D7069636B75 +701A626C6F636B2D657965626C6F73736F6D2D6F70656E2D6C6F6E6715626C6F636B2D65796562 +6C6F73736F6D2D6F70656E1B626C6F636B2D657965626C6F73736F6D2D636C6F73652D6C6F6E67 +16626C6F636B2D657965626C6F73736F6D2D636C6F736515626C6F636B2D657965626C6F73736F +6D2D69646C6516626C6F636B2D66656E63652D676174652D636C6F736515626C6F636B2D66656E +63652D676174652D6F70656E136974656D2D666972656368617267652D75736517626C6F636B2D +66697265666C792D627573682D69646C651C656E746974792D66697265776F726B2D726F636B65 +742D626C61737420656E746974792D66697265776F726B2D726F636B65742D626C6173742D6661 +7222656E746974792D66697265776F726B2D726F636B65742D6C617267652D626C61737426656E +746974792D66697265776F726B2D726F636B65742D6C617267652D626C6173742D6661721D656E +746974792D66697265776F726B2D726F636B65742D6C61756E63681C656E746974792D66697265 +776F726B2D726F636B65742D73686F6F741E656E746974792D66697265776F726B2D726F636B65 +742D7477696E6B6C6522656E746974792D66697265776F726B2D726F636B65742D7477696E6B6C +652D66617212626C6F636B2D666972652D616D6269656E7415626C6F636B2D666972652D657874 +696E677569736810656E746974792D666973682D7377696D1E656E746974792D66697368696E67 +2D626F626265722D72657472696576651C656E746974792D66697368696E672D626F626265722D +73706C6173681B656E746974792D66697368696E672D626F626265722D7468726F77166974656D +2D666C696E74616E64737465656C2D7573651C626C6F636B2D666C6F776572696E672D617A616C +65612D627265616B1B626C6F636B2D666C6F776572696E672D617A616C65612D66616C6C1A626C +6F636B2D666C6F776572696E672D617A616C65612D6869741C626C6F636B2D666C6F776572696E +672D617A616C65612D706C6163651B626C6F636B2D666C6F776572696E672D617A616C65612D73 +74657010656E746974792D666F782D616767726F12656E746974792D666F782D616D6269656E74 +0F656E746974792D666F782D6269746510656E746974792D666F782D64656174680E656E746974 +792D666F782D6561740F656E746974792D666F782D6875727412656E746974792D666F782D7363 +726565636810656E746974792D666F782D736C65657010656E746974792D666F782D736E696666 +0F656E746974792D666F782D7370697413656E746974792D666F782D74656C65706F72741B626C +6F636B2D737573706963696F75732D73616E642D627265616B1A626C6F636B2D73757370696369 +6F75732D73616E642D737465701B626C6F636B2D737573706963696F75732D73616E642D706C61 +636519626C6F636B2D737573706963696F75732D73616E642D6869741A626C6F636B2D73757370 +6963696F75732D73616E642D66616C6C1D626C6F636B2D737573706963696F75732D6772617665 +6C2D627265616B1C626C6F636B2D737573706963696F75732D67726176656C2D737465701D626C +6F636B2D737573706963696F75732D67726176656C2D706C6163651B626C6F636B2D7375737069 +63696F75732D67726176656C2D6869741C626C6F636B2D737573706963696F75732D6772617665 +6C2D66616C6C15626C6F636B2D66726F676C696768742D627265616B14626C6F636B2D66726F67 +6C696768742D66616C6C13626C6F636B2D66726F676C696768742D68697415626C6F636B2D6672 +6F676C696768742D706C61636514626C6F636B2D66726F676C696768742D7374657014626C6F63 +6B2D66726F67737061776E2D7374657015626C6F636B2D66726F67737061776E2D627265616B14 +626C6F636B2D66726F67737061776E2D66616C6C15626C6F636B2D66726F67737061776E2D6861 +74636813626C6F636B2D66726F67737061776E2D68697415626C6F636B2D66726F67737061776E +2D706C61636513656E746974792D66726F672D616D6269656E7411656E746974792D66726F672D +64656174680F656E746974792D66726F672D65617410656E746974792D66726F672D6875727415 +656E746974792D66726F672D6C61792D737061776E15656E746974792D66726F672D6C6F6E672D +6A756D7010656E746974792D66726F672D7374657012656E746974792D66726F672D746F6E6775 +6511626C6F636B2D726F6F74732D627265616B10626C6F636B2D726F6F74732D7374657011626C +6F636B2D726F6F74732D706C6163650F626C6F636B2D726F6F74732D68697410626C6F636B2D72 +6F6F74732D66616C6C1A626C6F636B2D6675726E6163652D666972652D637261636B6C6517656E +746974792D67656E657269632D6269672D66616C6C13656E746974792D67656E657269632D6275 +726E14656E746974792D67656E657269632D646561746814656E746974792D67656E657269632D +6472696E6B12656E746974792D67656E657269632D65617416656E746974792D67656E65726963 +2D6578706C6F64651E656E746974792D67656E657269632D657874696E67756973682D66697265 +13656E746974792D67656E657269632D6875727419656E746974792D67656E657269632D736D61 +6C6C2D66616C6C15656E746974792D67656E657269632D73706C61736813656E746974792D6765 +6E657269632D7377696D14656E746974792D67686173742D616D6269656E7412656E746974792D +67686173742D646561746811656E746974792D67686173742D6875727413656E746974792D6768 +6173742D73637265616D12656E746974792D67686173742D73686F6F7411656E746974792D6768 +6173742D7761726E18656E746974792D67686173746C696E672D616D6269656E7416656E746974 +792D67686173746C696E672D646561746815656E746974792D67686173746C696E672D68757274 +16656E746974792D67686173746C696E672D737061776E1D626C6F636B2D67696C6465642D626C +61636B73746F6E652D627265616B1C626C6F636B2D67696C6465642D626C61636B73746F6E652D +66616C6C1B626C6F636B2D67696C6465642D626C61636B73746F6E652D6869741D626C6F636B2D +67696C6465642D626C61636B73746F6E652D706C6163651C626C6F636B2D67696C6465642D626C +61636B73746F6E652D7374657011626C6F636B2D676C6173732D627265616B10626C6F636B2D67 +6C6173732D66616C6C0F626C6F636B2D676C6173732D68697411626C6F636B2D676C6173732D70 +6C61636510626C6F636B2D676C6173732D73746570156974656D2D676C6F772D696E6B2D736163 +2D7573651F656E746974792D676C6F772D6974656D2D6672616D652D6164642D6974656D1C656E +746974792D676C6F772D6974656D2D6672616D652D627265616B1C656E746974792D676C6F772D +6974656D2D6672616D652D706C61636522656E746974792D676C6F772D6974656D2D6672616D65 +2D72656D6F76652D6974656D22656E746974792D676C6F772D6974656D2D6672616D652D726F74 +6174652D6974656D19656E746974792D676C6F772D73717569642D616D6269656E7417656E7469 +74792D676C6F772D73717569642D646561746816656E746974792D676C6F772D73717569642D68 +75727418656E746974792D676C6F772D73717569642D73717569727413656E746974792D676F61 +742D616D6269656E7411656E746974792D676F61742D64656174680F656E746974792D676F6174 +2D65617410656E746974792D676F61742D6875727415656E746974792D676F61742D6C6F6E672D +6A756D7010656E746974792D676F61742D6D696C6B17656E746974792D676F61742D7072657061 +72652D72616D16656E746974792D676F61742D72616D2D696D7061637416656E746974792D676F +61742D686F726E2D627265616B1D656E746974792D676F61742D73637265616D696E672D616D62 +69656E741B656E746974792D676F61742D73637265616D696E672D646561746819656E74697479 +2D676F61742D73637265616D696E672D6561741A656E746974792D676F61742D73637265616D69 +6E672D687572741F656E746974792D676F61742D73637265616D696E672D6C6F6E672D6A756D70 +1A656E746974792D676F61742D73637265616D696E672D6D696C6B21656E746974792D676F6174 +2D73637265616D696E672D707265706172652D72616D20656E746974792D676F61742D73637265 +616D696E672D72616D2D696D7061637410656E746974792D676F61742D73746570196974656D2D +676F6C64656E2D64616E64656C696F6E2D7573651B6974656D2D676F6C64656E2D64616E64656C +696F6E2D756E75736511626C6F636B2D67726173732D627265616B10626C6F636B2D6772617373 +2D66616C6C0F626C6F636B2D67726173732D68697411626C6F636B2D67726173732D706C616365 +10626C6F636B2D67726173732D7374657012626C6F636B2D67726176656C2D627265616B11626C +6F636B2D67726176656C2D66616C6C10626C6F636B2D67726176656C2D68697412626C6F636B2D +67726176656C2D706C61636511626C6F636B2D67726176656C2D7374657014626C6F636B2D6772 +696E6473746F6E652D75736518626C6F636B2D67726F77696E672D706C616E742D63726F701765 +6E746974792D677561726469616E2D616D6269656E741C656E746974792D677561726469616E2D +616D6269656E742D6C616E6416656E746974792D677561726469616E2D61747461636B15656E74 +6974792D677561726469616E2D64656174681A656E746974792D677561726469616E2D64656174 +682D6C616E6414656E746974792D677561726469616E2D666C6F7014656E746974792D67756172 +6469616E2D6875727419656E746974792D677561726469616E2D687572742D6C616E6419626C6F +636B2D68616E67696E672D726F6F74732D627265616B18626C6F636B2D68616E67696E672D726F +6F74732D66616C6C17626C6F636B2D68616E67696E672D726F6F74732D68697419626C6F636B2D +68616E67696E672D726F6F74732D706C61636518626C6F636B2D68616E67696E672D726F6F7473 +2D7374657017626C6F636B2D68616E67696E672D7369676E2D7374657018626C6F636B2D68616E +67696E672D7369676E2D627265616B17626C6F636B2D68616E67696E672D7369676E2D66616C6C +16626C6F636B2D68616E67696E672D7369676E2D68697418626C6F636B2D68616E67696E672D73 +69676E2D706C6163651A656E746974792D68617070792D67686173742D616D6269656E7418656E +746974792D68617070792D67686173742D646561746817656E746974792D68617070792D676861 +73742D6875727419656E746974792D68617070792D67686173742D726964696E6716626C6F636B +2D68656176792D636F72652D627265616B15626C6F636B2D68656176792D636F72652D66616C6C +14626C6F636B2D68656176792D636F72652D68697416626C6F636B2D68656176792D636F72652D +706C61636515626C6F636B2D68656176792D636F72652D7374657023626C6F636B2D6E65746865 +722D776F6F642D68616E67696E672D7369676E2D7374657024626C6F636B2D6E65746865722D77 +6F6F642D68616E67696E672D7369676E2D627265616B23626C6F636B2D6E65746865722D776F6F +642D68616E67696E672D7369676E2D66616C6C22626C6F636B2D6E65746865722D776F6F642D68 +616E67696E672D7369676E2D68697424626C6F636B2D6E65746865722D776F6F642D68616E6769 +6E672D7369676E2D706C61636523626C6F636B2D62616D626F6F2D776F6F642D68616E67696E67 +2D7369676E2D7374657024626C6F636B2D62616D626F6F2D776F6F642D68616E67696E672D7369 +676E2D627265616B23626C6F636B2D62616D626F6F2D776F6F642D68616E67696E672D7369676E +2D66616C6C22626C6F636B2D62616D626F6F2D776F6F642D68616E67696E672D7369676E2D6869 +7424626C6F636B2D62616D626F6F2D776F6F642D68616E67696E672D7369676E2D706C61636519 +626C6F636B2D747269616C2D737061776E65722D627265616B18626C6F636B2D747269616C2D73 +7061776E65722D7374657019626C6F636B2D747269616C2D737061776E65722D706C6163651762 +6C6F636B2D747269616C2D737061776E65722D68697418626C6F636B2D747269616C2D73706177 +6E65722D66616C6C1D626C6F636B2D747269616C2D737061776E65722D737061776E2D6D6F6227 +626C6F636B2D747269616C2D737061776E65722D61626F75742D746F2D737061776E2D6974656D +1E626C6F636B2D747269616C2D737061776E65722D737061776E2D6974656D24626C6F636B2D74 +7269616C2D737061776E65722D737061776E2D6974656D2D626567696E21626C6F636B2D747269 +616C2D737061776E65722D6465746563742D706C6179657224626C6F636B2D747269616C2D7370 +61776E65722D6F6D696E6F75732D61637469766174651B626C6F636B2D747269616C2D73706177 +6E65722D616D6269656E7423626C6F636B2D747269616C2D737061776E65722D616D6269656E74 +2D6F6D696E6F757320626C6F636B2D747269616C2D737061776E65722D6F70656E2D7368757474 +657221626C6F636B2D747269616C2D737061776E65722D636C6F73652D736875747465721E626C +6F636B2D747269616C2D737061776E65722D656A6563742D6974656D18656E746974792D686170 +70792D67686173742D65717569701A656E746974792D68617070792D67686173742D756E657175 +697025656E746974792D68617070792D67686173742D6861726E6573732D676F67676C65732D75 +7027656E746974792D68617070792D67686173742D6861726E6573732D676F67676C65732D646F +776E0D6974656D2D686F652D74696C6C15656E746974792D686F676C696E2D616D6269656E7413 +656E746974792D686F676C696E2D616E67727914656E746974792D686F676C696E2D6174746163 +6B24656E746974792D686F676C696E2D636F6E7665727465642D746F2D7A6F6D62696669656413 +656E746974792D686F676C696E2D646561746812656E746974792D686F676C696E2D6875727415 +656E746974792D686F676C696E2D7265747265617412656E746974792D686F676C696E2D737465 +7017626C6F636B2D686F6E65792D626C6F636B2D627265616B16626C6F636B2D686F6E65792D62 +6C6F636B2D66616C6C15626C6F636B2D686F6E65792D626C6F636B2D68697417626C6F636B2D68 +6F6E65792D626C6F636B2D706C61636517626C6F636B2D686F6E65792D626C6F636B2D736C6964 +6516626C6F636B2D686F6E65792D626C6F636B2D73746570156974656D2D686F6E6579636F6D62 +2D7761782D6F6E176974656D2D686F6E65792D626F74746C652D6472696E6B166974656D2D676F +61742D686F726E2D736F756E642D30166974656D2D676F61742D686F726E2D736F756E642D3116 +6974656D2D676F61742D686F726E2D736F756E642D32166974656D2D676F61742D686F726E2D73 +6F756E642D33166974656D2D676F61742D686F726E2D736F756E642D34166974656D2D676F6174 +2D686F726E2D736F756E642D35166974656D2D676F61742D686F726E2D736F756E642D36166974 +656D2D676F61742D686F726E2D736F756E642D3714656E746974792D686F7273652D616D626965 +6E7419656E746974792D626162792D686F7273652D616D6269656E7412656E746974792D686F72 +73652D616E67727917656E746974792D626162792D686F7273652D616E67727912656E74697479 +2D686F7273652D61726D6F72186974656D2D686F7273652D61726D6F722D756E65717569701465 +6E746974792D686F7273652D6272656174686519656E746974792D626162792D686F7273652D62 +72656174686512656E746974792D686F7273652D646561746817656E746974792D626162792D68 +6F7273652D646561746810656E746974792D686F7273652D65617415656E746974792D62616279 +2D686F7273652D65617413656E746974792D686F7273652D67616C6C6F7011656E746974792D68 +6F7273652D6875727416656E746974792D626162792D686F7273652D6875727411656E74697479 +2D686F7273652D6A756D7011656E746974792D686F7273652D6C616E6416656E746974792D6261 +62792D686F7273652D6C616E6413656E746974792D686F7273652D736164646C6511656E746974 +792D686F7273652D7374657016656E746974792D626162792D686F7273652D7374657016656E74 +6974792D686F7273652D737465702D776F6F6417656E746974792D686F7374696C652D6269672D +66616C6C14656E746974792D686F7374696C652D646561746813656E746974792D686F7374696C +652D6875727419656E746974792D686F7374696C652D736D616C6C2D66616C6C15656E74697479 +2D686F7374696C652D73706C61736813656E746974792D686F7374696C652D7377696D13656E74 +6974792D6875736B2D616D6269656E741F656E746974792D6875736B2D636F6E7665727465642D +746F2D7A6F6D62696511656E746974792D6875736B2D646561746810656E746974792D6875736B +2D6875727410656E746974792D6875736B2D7374657019656E746974792D696C6C7573696F6E65 +722D616D6269656E741C656E746974792D696C6C7573696F6E65722D636173742D7370656C6C17 +656E746974792D696C6C7573696F6E65722D646561746816656E746974792D696C6C7573696F6E +65722D687572741D656E746974792D696C6C7573696F6E65722D6D6972726F722D6D6F76652365 +6E746974792D696C6C7573696F6E65722D707265706172652D626C696E646E65737320656E7469 +74792D696C6C7573696F6E65722D707265706172652D6D6972726F72106974656D2D696E6B2D73 +61632D75736510626C6F636B2D69726F6E2D627265616B0F626C6F636B2D69726F6E2D73746570 +10626C6F636B2D69726F6E2D706C6163650E626C6F636B2D69726F6E2D6869740F626C6F636B2D +69726F6E2D66616C6C15626C6F636B2D69726F6E2D646F6F722D636C6F736514626C6F636B2D69 +726F6E2D646F6F722D6F70656E18656E746974792D69726F6E2D676F6C656D2D61747461636B18 +656E746974792D69726F6E2D676F6C656D2D64616D61676517656E746974792D69726F6E2D676F +6C656D2D646561746816656E746974792D69726F6E2D676F6C656D2D6875727418656E74697479 +2D69726F6E2D676F6C656D2D72657061697216656E746974792D69726F6E2D676F6C656D2D7374 +657019626C6F636B2D69726F6E2D74726170646F6F722D636C6F736518626C6F636B2D69726F6E +2D74726170646F6F722D6F70656E1A656E746974792D6974656D2D6672616D652D6164642D6974 +656D17656E746974792D6974656D2D6672616D652D627265616B17656E746974792D6974656D2D +6672616D652D706C6163651D656E746974792D6974656D2D6672616D652D72656D6F76652D6974 +656D1D656E746974792D6974656D2D6672616D652D726F746174652D6974656D11656E74697479 +2D6974656D2D627265616B12656E746974792D6974656D2D7069636B757012626C6F636B2D6C61 +646465722D627265616B11626C6F636B2D6C61646465722D66616C6C10626C6F636B2D6C616464 +65722D68697412626C6F636B2D6C61646465722D706C61636511626C6F636B2D6C61646465722D +7374657013626C6F636B2D6C616E7465726E2D627265616B12626C6F636B2D6C616E7465726E2D +66616C6C11626C6F636B2D6C616E7465726E2D68697413626C6F636B2D6C616E7465726E2D706C +61636512626C6F636B2D6C616E7465726E2D737465701E626C6F636B2D6C617267652D616D6574 +687973742D6275642D627265616B1E626C6F636B2D6C617267652D616D6574687973742D627564 +2D706C61636512626C6F636B2D6C6176612D616D6269656E7415626C6F636B2D6C6176612D6578 +74696E67756973680E626C6F636B2D6C6176612D706F7017626C6F636B2D6C6561662D6C697474 +65722D627265616B16626C6F636B2D6C6561662D6C69747465722D7374657017626C6F636B2D6C +6561662D6C69747465722D706C61636515626C6F636B2D6C6561662D6C69747465722D68697416 +626C6F636B2D6C6561662D6C69747465722D66616C6C106974656D2D6C6561642D756E74696564 +0E6974656D2D6C6561642D746965640F6974656D2D6C6561642D627265616B11626C6F636B2D6C +657665722D636C69636B1C656E746974792D6C696768746E696E672D626F6C742D696D70616374 +1D656E746974792D6C696768746E696E672D626F6C742D7468756E6465721D656E746974792D6C +696E676572696E672D706F74696F6E2D7468726F7714656E746974792D6C6C616D612D616D6269 +656E7412656E746974792D6C6C616D612D616E67727912656E746974792D6C6C616D612D636865 +737412656E746974792D6C6C616D612D646561746810656E746974792D6C6C616D612D65617411 +656E746974792D6C6C616D612D6875727411656E746974792D6C6C616D612D7370697411656E74 +6974792D6C6C616D612D7374657011656E746974792D6C6C616D612D73776167196974656D2D6C +6C616D612D6361727065742D756E65717569701D656E746974792D6D61676D612D637562652D64 +656174682D736D616C6C15626C6F636B2D6C6F646573746F6E652D627265616B14626C6F636B2D +6C6F646573746F6E652D7374657015626C6F636B2D6C6F646573746F6E652D706C61636513626C +6F636B2D6C6F646573746F6E652D68697414626C6F636B2D6C6F646573746F6E652D66616C6C1B +6974656D2D6C6F646573746F6E652D636F6D706173732D6C6F636B126974656D2D73706561722D +6C756E67652D31126974656D2D73706561722D6C756E67652D32126974656D2D73706561722D6C +756E67652D33136974656D2D6D6163652D736D6173682D616972166974656D2D6D6163652D736D +6173682D67726F756E641C6974656D2D6D6163652D736D6173682D67726F756E642D6865617679 +17656E746974792D6D61676D612D637562652D646561746816656E746974792D6D61676D612D63 +7562652D687572741C656E746974792D6D61676D612D637562652D687572742D736D616C6C1665 +6E746974792D6D61676D612D637562652D6A756D7018656E746974792D6D61676D612D63756265 +2D7371756973681E656E746974792D6D61676D612D637562652D7371756973682D736D616C6C1A +626C6F636B2D6D616E67726F76652D726F6F74732D627265616B19626C6F636B2D6D616E67726F +76652D726F6F74732D66616C6C18626C6F636B2D6D616E67726F76652D726F6F74732D6869741A +626C6F636B2D6D616E67726F76652D726F6F74732D706C61636519626C6F636B2D6D616E67726F +76652D726F6F74732D737465701F626C6F636B2D6D656469756D2D616D6574687973742D627564 +2D627265616B1F626C6F636B2D6D656469756D2D616D6574687973742D6275642D706C61636511 +626C6F636B2D6D6574616C2D627265616B10626C6F636B2D6D6574616C2D66616C6C0F626C6F63 +6B2D6D6574616C2D68697411626C6F636B2D6D6574616C2D706C61636524626C6F636B2D6D6574 +616C2D70726573737572652D706C6174652D636C69636B2D6F666623626C6F636B2D6D6574616C +2D70726573737572652D706C6174652D636C69636B2D6F6E10626C6F636B2D6D6574616C2D7374 +657021656E746974792D6D696E65636172742D696E736964652D756E646572776174657216656E +746974792D6D696E65636172742D696E7369646516656E746974792D6D696E65636172742D7269 +64696E6718656E746974792D6D6F6F7368726F6F6D2D636F6E7665727414656E746974792D6D6F +6F7368726F6F6D2D65617415656E746974792D6D6F6F7368726F6F6D2D6D696C6B20656E746974 +792D6D6F6F7368726F6F6D2D737573706963696F75732D6D696C6B16656E746974792D6D6F6F73 +68726F6F6D2D736865617217626C6F636B2D6D6F73732D6361727065742D627265616B16626C6F +636B2D6D6F73732D6361727065742D66616C6C15626C6F636B2D6D6F73732D6361727065742D68 +697417626C6F636B2D6D6F73732D6361727065742D706C61636516626C6F636B2D6D6F73732D63 +61727065742D7374657017626C6F636B2D70696E6B2D706574616C732D627265616B16626C6F63 +6B2D70696E6B2D706574616C732D66616C6C15626C6F636B2D70696E6B2D706574616C732D6869 +7417626C6F636B2D70696E6B2D706574616C732D706C61636516626C6F636B2D70696E6B2D7065 +74616C732D7374657010626C6F636B2D6D6F73732D627265616B0F626C6F636B2D6D6F73732D66 +616C6C0E626C6F636B2D6D6F73732D68697410626C6F636B2D6D6F73732D706C6163650F626C6F +636B2D6D6F73732D737465700F626C6F636B2D6D75642D627265616B0E626C6F636B2D6D75642D +66616C6C0D626C6F636B2D6D75642D6869740F626C6F636B2D6D75642D706C6163650E626C6F63 +6B2D6D75642D7374657016626C6F636B2D6D75642D627269636B732D627265616B15626C6F636B +2D6D75642D627269636B732D66616C6C14626C6F636B2D6D75642D627269636B732D6869741662 +6C6F636B2D6D75642D627269636B732D706C61636515626C6F636B2D6D75642D627269636B732D +7374657020626C6F636B2D6D756464792D6D616E67726F76652D726F6F74732D627265616B1F62 +6C6F636B2D6D756464792D6D616E67726F76652D726F6F74732D66616C6C1E626C6F636B2D6D75 +6464792D6D616E67726F76652D726F6F74732D68697420626C6F636B2D6D756464792D6D616E67 +726F76652D726F6F74732D706C6163651F626C6F636B2D6D756464792D6D616E67726F76652D72 +6F6F74732D7374657013656E746974792D6D756C652D616D6269656E7411656E746974792D6D75 +6C652D616E67727911656E746974792D6D756C652D636865737411656E746974792D6D756C652D +64656174680F656E746974792D6D756C652D65617410656E746974792D6D756C652D6875727410 +656E746974792D6D756C652D6A756D700E6D757369632D63726561746976650D6D757369632D63 +7265646974730C6D757369632D646973632D350D6D757369632D646973632D31310D6D75736963 +2D646973632D3133116D757369632D646973632D626C6F636B73116D757369632D646973632D62 +6F756E63650E6D757369632D646973632D636174106D757369632D646973632D63686972700E6D +757369632D646973632D666172176D757369632D646973632D6C6176612D636869636B656E0F6D +757369632D646973632D6D616C6C126D757369632D646973632D6D656C6C6F6869126D75736963 +2D646973632D706967737465700F6D757369632D646973632D7374616C106D757369632D646973 +632D73747261640F6D757369632D646973632D776169740F6D757369632D646973632D77617264 +146D757369632D646973632D6F7468657273696465106D757369632D646973632D72656C696312 +6D757369632D646973632D63726561746F721C6D757369632D646973632D63726561746F722D6D +757369632D626F78146D757369632D646973632D707265636970696365106D757369632D646973 +632D74656172730C6D757369632D647261676F6E096D757369632D656E640A6D757369632D6761 +6D650A6D757369632D6D656E751A6D757369632D6E65746865722D626173616C742D64656C7461 +731B6D757369632D6E65746865722D6372696D736F6E2D666F72657374196D757369632D6F7665 +72776F726C642D646565702D6461726B1F6D757369632D6F766572776F726C642D647269707374 +6F6E652D6361766573156D757369632D6F766572776F726C642D67726F76651C6D757369632D6F +766572776F726C642D6A61676765642D7065616B731A6D757369632D6F766572776F726C642D6C +7573682D6361766573156D757369632D6F766572776F726C642D7377616D70166D757369632D6F +766572776F726C642D666F72657374206D757369632D6F766572776F726C642D6F6C642D67726F +7774682D7461696761166D757369632D6F766572776F726C642D6D6561646F771C6D757369632D +6F766572776F726C642D6368657272792D67726F76651A6D757369632D6E65746865722D6E6574 +6865722D7761737465731C6D757369632D6F766572776F726C642D66726F7A656E2D7065616B73 +1C6D757369632D6F766572776F726C642D736E6F77792D736C6F7065731D6D757369632D6E6574 +6865722D736F756C2D73616E642D76616C6C65791B6D757369632D6F766572776F726C642D7374 +6F6E792D7065616B731A6D757369632D6E65746865722D7761727065642D666F726573741D6D75 +7369632D6F766572776F726C642D666C6F7765722D666F72657374166D757369632D6F76657277 +6F726C642D646573657274186D757369632D6F766572776F726C642D6261646C616E6473166D75 +7369632D6F766572776F726C642D6A756E676C651D6D757369632D6F766572776F726C642D7370 +617273652D6A756E676C651D6D757369632D6F766572776F726C642D62616D626F6F2D6A756E67 +6C651C6D757369632D6F766572776F726C642D73756C6675722D6361766573116D757369632D75 +6E6465722D776174657217656E746974792D6E617574696C75732D616D6269656E741C656E7469 +74792D6E617574696C75732D616D6269656E742D6C616E6414656E746974792D6E617574696C75 +732D6461736819656E746974792D6E617574696C75732D646173682D6C616E641A656E74697479 +2D6E617574696C75732D646173682D72656164791F656E746974792D6E617574696C75732D6461 +73682D72656164792D6C616E6415656E746974792D6E617574696C75732D64656174681A656E74 +6974792D6E617574696C75732D64656174682D6C616E6413656E746974792D6E617574696C7573 +2D65617414656E746974792D6E617574696C75732D6875727419656E746974792D6E617574696C +75732D687572742D6C616E6414656E746974792D6E617574696C75732D7377696D19626C6F636B +2D6E65746865722D627269636B732D627265616B18626C6F636B2D6E65746865722D627269636B +732D7374657019626C6F636B2D6E65746865722D627269636B732D706C61636517626C6F636B2D +6E65746865722D627269636B732D68697418626C6F636B2D6E65746865722D627269636B732D66 +616C6C17626C6F636B2D6E65746865722D776172742D627265616B166974656D2D6E6574686572 +2D776172742D706C616E7417626C6F636B2D6E65746865722D776F6F642D627265616B16626C6F +636B2D6E65746865722D776F6F642D66616C6C15626C6F636B2D6E65746865722D776F6F642D68 +697417626C6F636B2D6E65746865722D776F6F642D706C61636516626C6F636B2D6E6574686572 +2D776F6F642D737465701C626C6F636B2D6E65746865722D776F6F642D646F6F722D636C6F7365 +1B626C6F636B2D6E65746865722D776F6F642D646F6F722D6F70656E20626C6F636B2D6E657468 +65722D776F6F642D74726170646F6F722D636C6F73651F626C6F636B2D6E65746865722D776F6F +642D74726170646F6F722D6F70656E22626C6F636B2D6E65746865722D776F6F642D627574746F +6E2D636C69636B2D6F666621626C6F636B2D6E65746865722D776F6F642D627574746F6E2D636C +69636B2D6F6E2A626C6F636B2D6E65746865722D776F6F642D70726573737572652D706C617465 +2D636C69636B2D6F666629626C6F636B2D6E65746865722D776F6F642D70726573737572652D70 +6C6174652D636C69636B2D6F6E22626C6F636B2D6E65746865722D776F6F642D66656E63652D67 +6174652D636C6F736521626C6F636B2D6E65746865722D776F6F642D66656E63652D676174652D +6F70656E13696E74656E74696F6E616C6C792D656D70747916626C6F636B2D7061636B65642D6D +75642D627265616B15626C6F636B2D7061636B65642D6D75642D66616C6C14626C6F636B2D7061 +636B65642D6D75642D68697416626C6F636B2D7061636B65642D6D75642D706C61636515626C6F +636B2D7061636B65642D6D75642D7374657010626C6F636B2D7374656D2D627265616B0F626C6F +636B2D7374656D2D7374657010626C6F636B2D7374656D2D706C6163650E626C6F636B2D737465 +6D2D6869740F626C6F636B2D7374656D2D66616C6C12626C6F636B2D6E796C69756D2D62726561 +6B11626C6F636B2D6E796C69756D2D7374657012626C6F636B2D6E796C69756D2D706C61636510 +626C6F636B2D6E796C69756D2D68697411626C6F636B2D6E796C69756D2D66616C6C1A626C6F63 +6B2D6E65746865722D7370726F7574732D627265616B19626C6F636B2D6E65746865722D737072 +6F7574732D737465701A626C6F636B2D6E65746865722D7370726F7574732D706C61636518626C +6F636B2D6E65746865722D7370726F7574732D68697419626C6F636B2D6E65746865722D737072 +6F7574732D66616C6C12626C6F636B2D66756E6775732D627265616B11626C6F636B2D66756E67 +75732D7374657012626C6F636B2D66756E6775732D706C61636510626C6F636B2D66756E677573 +2D68697411626C6F636B2D66756E6775732D66616C6C19626C6F636B2D77656570696E672D7669 +6E65732D627265616B18626C6F636B2D77656570696E672D76696E65732D7374657019626C6F63 +6B2D77656570696E672D76696E65732D706C61636517626C6F636B2D77656570696E672D76696E +65732D68697418626C6F636B2D77656570696E672D76696E65732D66616C6C16626C6F636B2D77 +6172742D626C6F636B2D627265616B15626C6F636B2D776172742D626C6F636B2D737465701662 +6C6F636B2D776172742D626C6F636B2D706C61636514626C6F636B2D776172742D626C6F636B2D +68697415626C6F636B2D776172742D626C6F636B2D66616C6C1B626C6F636B2D6E657468657269 +74652D626C6F636B2D627265616B1A626C6F636B2D6E65746865726974652D626C6F636B2D7374 +65701B626C6F636B2D6E65746865726974652D626C6F636B2D706C61636519626C6F636B2D6E65 +746865726974652D626C6F636B2D6869741A626C6F636B2D6E65746865726974652D626C6F636B +2D66616C6C16626C6F636B2D6E65746865727261636B2D627265616B15626C6F636B2D6E657468 +65727261636B2D7374657016626C6F636B2D6E65746865727261636B2D706C61636514626C6F63 +6B2D6E65746865727261636B2D68697415626C6F636B2D6E65746865727261636B2D66616C6C19 +626C6F636B2D6E6F74652D626C6F636B2D626173656472756D15626C6F636B2D6E6F74652D626C +6F636B2D6261737315626C6F636B2D6E6F74652D626C6F636B2D62656C6C16626C6F636B2D6E6F +74652D626C6F636B2D6368696D6516626C6F636B2D6E6F74652D626C6F636B2D666C7574651762 +6C6F636B2D6E6F74652D626C6F636B2D67756974617215626C6F636B2D6E6F74652D626C6F636B +2D6861727014626C6F636B2D6E6F74652D626C6F636B2D68617416626C6F636B2D6E6F74652D62 +6C6F636B2D706C696E6716626C6F636B2D6E6F74652D626C6F636B2D736E61726518626C6F636B +2D6E6F74652D626C6F636B2D7472756D70657420626C6F636B2D6E6F74652D626C6F636B2D7472 +756D7065742D6578706F73656421626C6F636B2D6E6F74652D626C6F636B2D7472756D7065742D +6F786964697A656422626C6F636B2D6E6F74652D626C6F636B2D7472756D7065742D7765617468 +657265641A626C6F636B2D6E6F74652D626C6F636B2D78796C6F70686F6E651F626C6F636B2D6E +6F74652D626C6F636B2D69726F6E2D78796C6F70686F6E6519626C6F636B2D6E6F74652D626C6F +636B2D636F772D62656C6C1B626C6F636B2D6E6F74652D626C6F636B2D64696467657269646F6F +14626C6F636B2D6E6F74652D626C6F636B2D62697416626C6F636B2D6E6F74652D626C6F636B2D +62616E6A6F1F626C6F636B2D6E6F74652D626C6F636B2D696D69746174652D7A6F6D6269652162 +6C6F636B2D6E6F74652D626C6F636B2D696D69746174652D736B656C65746F6E20626C6F636B2D +6E6F74652D626C6F636B2D696D69746174652D6372656570657225626C6F636B2D6E6F74652D62 +6C6F636B2D696D69746174652D656E6465722D647261676F6E28626C6F636B2D6E6F74652D626C +6F636B2D696D69746174652D7769746865722D736B656C65746F6E1F626C6F636B2D6E6F74652D +626C6F636B2D696D69746174652D7069676C696E12656E746974792D6F63656C6F742D68757274 +15656E746974792D6F63656C6F742D616D6269656E7413656E746974792D6F63656C6F742D6465 +6174681B6974656D2D6F6D696E6F75732D626F74746C652D646973706F736515656E746974792D +7061696E74696E672D627265616B15656E746974792D7061696E74696E672D706C6163651C626C +6F636B2D70616C652D68616E67696E672D6D6F73732D69646C6517656E746974792D70616E6461 +2D7072652D736E65657A6513656E746974792D70616E64612D736E65657A6514656E746974792D +70616E64612D616D6269656E7412656E746974792D70616E64612D646561746810656E74697479 +2D70616E64612D65617411656E746974792D70616E64612D7374657017656E746974792D70616E +64612D63616E742D62726565641F656E746974792D70616E64612D616767726573736976652D61 +6D6269656E741C656E746974792D70616E64612D776F72726965642D616D6269656E7411656E74 +6974792D70616E64612D6875727411656E746974792D70616E64612D6269746516656E74697479 +2D706172636865642D616D6269656E7414656E746974792D706172636865642D64656174681365 +6E746974792D706172636865642D6875727413656E746974792D706172636865642D7374657015 +656E746974792D706172726F742D616D6269656E7413656E746974792D706172726F742D646561 +746811656E746974792D706172726F742D65617411656E746974792D706172726F742D666C7912 +656E746974792D706172726F742D687572741B656E746974792D706172726F742D696D69746174 +652D626C617A651C656E746974792D706172726F742D696D69746174652D626F676765641C656E +746974792D706172726F742D696D69746174652D627265657A6520656E746974792D706172726F +742D696D69746174652D63616D656C2D6875736B1E656E746974792D706172726F742D696D6974 +6174652D637265616B696E671D656E746974792D706172726F742D696D69746174652D63726565 +7065721D656E746974792D706172726F742D696D69746174652D64726F776E656424656E746974 +792D706172726F742D696D69746174652D656C6465722D677561726469616E22656E746974792D +706172726F742D696D69746174652D656E6465722D647261676F6E1F656E746974792D70617272 +6F742D696D69746174652D656E6465726D6974651C656E746974792D706172726F742D696D6974 +6174652D65766F6B65721B656E746974792D706172726F742D696D69746174652D67686173741E +656E746974792D706172726F742D696D69746174652D677561726469616E1C656E746974792D70 +6172726F742D696D69746174652D686F676C696E1A656E746974792D706172726F742D696D6974 +6174652D6875736B20656E746974792D706172726F742D696D69746174652D696C6C7573696F6E +657220656E746974792D706172726F742D696D69746174652D6D61676D612D637562651D656E74 +6974792D706172726F742D696D69746174652D7068616E746F6D1D656E746974792D706172726F +742D696D69746174652D706172636865641C656E746974792D706172726F742D696D6974617465 +2D7069676C696E22656E746974792D706172726F742D696D69746174652D7069676C696E2D6272 +7574651E656E746974792D706172726F742D696D69746174652D70696C6C616765721D656E7469 +74792D706172726F742D696D69746174652D726176616765721D656E746974792D706172726F74 +2D696D69746174652D7368756C6B657220656E746974792D706172726F742D696D69746174652D +73696C766572666973681E656E746974792D706172726F742D696D69746174652D736B656C6574 +6F6E1B656E746974792D706172726F742D696D69746174652D736C696D651C656E746974792D70 +6172726F742D696D69746174652D7370696465721B656E746974792D706172726F742D696D6974 +6174652D737472617919656E746974792D706172726F742D696D69746174652D76657820656E74 +6974792D706172726F742D696D69746174652D76696E64696361746F721C656E746974792D7061 +72726F742D696D69746174652D77617264656E1B656E746974792D706172726F742D696D697461 +74652D77697463681C656E746974792D706172726F742D696D69746174652D7769746865722565 +6E746974792D706172726F742D696D69746174652D7769746865722D736B656C65746F6E1C656E +746974792D706172726F742D696D69746174652D7A6F676C696E1C656E746974792D706172726F +742D696D69746174652D7A6F6D62696522656E746974792D706172726F742D696D69746174652D +7A6F6D6269652D686F72736525656E746974792D706172726F742D696D69746174652D7A6F6D62 +69652D6E617574696C757325656E746974792D706172726F742D696D69746174652D7A6F6D6269 +652D76696C6C6167657212656E746974792D706172726F742D7374657016656E746974792D7068 +616E746F6D2D616D6269656E7413656E746974792D7068616E746F6D2D6269746514656E746974 +792D7068616E746F6D2D646561746813656E746974792D7068616E746F6D2D666C617013656E74 +6974792D7068616E746F6D2D6875727414656E746974792D7068616E746F6D2D73776F6F701165 +6E746974792D7069672D736164646C650F656E746974792D7069672D7374657014656E74697479 +2D626162792D7069672D7374657017656E746974792D626162792D7069672D616D6269656E7413 +656E746974792D626162792D7069672D65617414656E746974792D626162792D7069672D687572 +7415656E746974792D626162792D7069672D646561746812656E746974792D7069672D616D6269 +656E740F656E746974792D7069672D6875727410656E746974792D7069672D64656174680E656E +746974792D7069672D65617417656E746974792D7069672D6D696E692D616D6269656E7414656E +746974792D7069672D6D696E692D6875727415656E746974792D7069672D6D696E692D64656174 +6813656E746974792D7069672D6D696E692D65617416656E746974792D7069672D6269672D616D +6269656E7413656E746974792D7069672D6269672D6875727414656E746974792D7069672D6269 +672D646561746812656E746974792D7069672D6269672D6561741B656E746974792D7069676C69 +6E2D61646D6972696E672D6974656D15656E746974792D7069676C696E2D616D6269656E741365 +6E746974792D7069676C696E2D616E67727917656E746974792D7069676C696E2D63656C656272 +61746513656E746974792D7069676C696E2D646561746815656E746974792D7069676C696E2D6A +65616C6F757312656E746974792D7069676C696E2D6875727415656E746974792D7069676C696E +2D7265747265617412656E746974792D7069676C696E2D7374657024656E746974792D7069676C +696E2D636F6E7665727465642D746F2D7A6F6D6269666965641B656E746974792D7069676C696E +2D62727574652D616D6269656E7419656E746974792D7069676C696E2D62727574652D616E6772 +7919656E746974792D7069676C696E2D62727574652D646561746818656E746974792D7069676C +696E2D62727574652D6875727418656E746974792D7069676C696E2D62727574652D737465702A +656E746974792D7069676C696E2D62727574652D636F6E7665727465642D746F2D7A6F6D626966 +69656417656E746974792D70696C6C616765722D616D6269656E7419656E746974792D70696C6C +616765722D63656C65627261746515656E746974792D70696C6C616765722D646561746814656E +746974792D70696C6C616765722D6875727415626C6F636B2D706973746F6E2D636F6E74726163 +7413626C6F636B2D706973746F6E2D657874656E6419656E746974792D706C617965722D617474 +61636B2D637269741E656E746974792D706C617965722D61747461636B2D6B6E6F636B6261636B +1D656E746974792D706C617965722D61747461636B2D6E6F64616D6167651B656E746974792D70 +6C617965722D61747461636B2D7374726F6E671A656E746974792D706C617965722D6174746163 +6B2D737765657019656E746974792D706C617965722D61747461636B2D7765616B16656E746974 +792D706C617965722D6269672D66616C6C14656E746974792D706C617965722D62726561746812 +656E746974792D706C617965722D6275727013656E746974792D706C617965722D646561746812 +656E746974792D706C617965722D6875727418656E746974792D706C617965722D687572742D64 +726F776E19656E746974792D706C617965722D687572742D667265657A651A656E746974792D70 +6C617965722D687572742D6F6E2D6669726523656E746974792D706C617965722D687572742D73 +776565742D62657272792D6275736815656E746974792D706C617965722D6C6576656C75701865 +6E746974792D706C617965722D736D616C6C2D66616C6C14656E746974792D706C617965722D73 +706C6173681F656E746974792D706C617965722D73706C6173682D686967682D73706565641265 +6E746974792D706C617965722D7377696D16656E746974792D706C617965722D74656C65706F72 +7419656E746974792D706F6C61722D626561722D616D6269656E741E656E746974792D706F6C61 +722D626561722D616D6269656E742D6261627917656E746974792D706F6C61722D626561722D64 +6561746816656E746974792D706F6C61722D626561722D6875727416656E746974792D706F6C61 +722D626561722D7374657019656E746974792D706F6C61722D626561722D7761726E696E671E62 +6C6F636B2D706F6C69736865642D64656570736C6174652D627265616B1D626C6F636B2D706F6C +69736865642D64656570736C6174652D66616C6C1C626C6F636B2D706F6C69736865642D646565 +70736C6174652D6869741E626C6F636B2D706F6C69736865642D64656570736C6174652D706C61 +63651D626C6F636B2D706F6C69736865642D64656570736C6174652D7374657014626C6F636B2D +706F7274616C2D616D6269656E7413626C6F636B2D706F7274616C2D74726176656C14626C6F63 +6B2D706F7274616C2D7472696767657217626C6F636B2D706F776465722D736E6F772D62726561 +6B16626C6F636B2D706F776465722D736E6F772D66616C6C15626C6F636B2D706F776465722D73 +6E6F772D68697417626C6F636B2D706F776465722D736E6F772D706C61636516626C6F636B2D70 +6F776465722D736E6F772D737465701B656E746974792D7075666665722D666973682D626C6F77 +2D6F75741A656E746974792D7075666665722D666973682D626C6F772D757018656E746974792D +7075666665722D666973682D646561746817656E746974792D7075666665722D666973682D666C +6F7017656E746974792D7075666665722D666973682D6875727418656E746974792D7075666665 +722D666973682D7374696E6713626C6F636B2D70756D706B696E2D636172766515656E74697479 +2D7261626269742D616D6269656E7414656E746974792D7261626269742D61747461636B13656E +746974792D7261626269742D646561746812656E746974792D7261626269742D6875727412656E +746974792D7261626269742D6A756D700F6576656E742D726169642D686F726E16656E74697479 +2D726176616765722D616D6269656E7415656E746974792D726176616765722D61747461636B18 +656E746974792D726176616765722D63656C65627261746514656E746974792D72617661676572 +2D646561746813656E746974792D726176616765722D6875727413656E746974792D7261766167 +65722D7374657016656E746974792D726176616765722D7374756E6E656413656E746974792D72 +6176616765722D726F61721B626C6F636B2D6E65746865722D676F6C642D6F72652D627265616B +1A626C6F636B2D6E65746865722D676F6C642D6F72652D66616C6C19626C6F636B2D6E65746865 +722D676F6C642D6F72652D6869741B626C6F636B2D6E65746865722D676F6C642D6F72652D706C +6163651A626C6F636B2D6E65746865722D676F6C642D6F72652D7374657016626C6F636B2D6E65 +746865722D6F72652D627265616B15626C6F636B2D6E65746865722D6F72652D66616C6C14626C +6F636B2D6E65746865722D6F72652D68697416626C6F636B2D6E65746865722D6F72652D706C61 +636515626C6F636B2D6E65746865722D6F72652D737465701C626C6F636B2D72656473746F6E65 +2D746F7263682D6275726E6F757411626C6F636B2D726573696E2D627265616B10626C6F636B2D +726573696E2D66616C6C11626C6F636B2D726573696E2D706C61636510626C6F636B2D72657369 +6E2D7374657018626C6F636B2D726573696E2D627269636B732D627265616B17626C6F636B2D72 +6573696E2D627269636B732D66616C6C16626C6F636B2D726573696E2D627269636B732D686974 +18626C6F636B2D726573696E2D627269636B732D706C61636517626C6F636B2D726573696E2D62 +7269636B732D737465701C626C6F636B2D7265737061776E2D616E63686F722D616D6269656E74 +1B626C6F636B2D7265737061776E2D616E63686F722D6368617267651C626C6F636B2D72657370 +61776E2D616E63686F722D6465706C6574651E626C6F636B2D7265737061776E2D616E63686F72 +2D7365742D737061776E17626C6F636B2D726F6F7465642D646972742D627265616B16626C6F63 +6B2D726F6F7465642D646972742D66616C6C15626C6F636B2D726F6F7465642D646972742D6869 +7417626C6F636B2D726F6F7465642D646972742D706C61636516626C6F636B2D726F6F7465642D +646972742D7374657015656E746974792D73616C6D6F6E2D616D6269656E7413656E746974792D +73616C6D6F6E2D646561746812656E746974792D73616C6D6F6E2D666C6F7012656E746974792D +73616C6D6F6E2D6875727410626C6F636B2D73616E642D627265616B0F626C6F636B2D73616E64 +2D66616C6C0E626C6F636B2D73616E642D68697410626C6F636B2D73616E642D706C6163650F62 +6C6F636B2D73616E642D737465700F626C6F636B2D73616E642D69646C6517626C6F636B2D7363 +6166666F6C64696E672D627265616B16626C6F636B2D73636166666F6C64696E672D66616C6C15 +626C6F636B2D73636166666F6C64696E672D68697417626C6F636B2D73636166666F6C64696E67 +2D706C61636516626C6F636B2D73636166666F6C64696E672D7374657012626C6F636B2D736375 +6C6B2D73707265616412626C6F636B2D7363756C6B2D63686172676511626C6F636B2D7363756C +6B2D627265616B10626C6F636B2D7363756C6B2D66616C6C0F626C6F636B2D7363756C6B2D6869 +7411626C6F636B2D7363756C6B2D706C61636510626C6F636B2D7363756C6B2D737465701A626C +6F636B2D7363756C6B2D636174616C7973742D626C6F6F6D1A626C6F636B2D7363756C6B2D6361 +74616C7973742D627265616B19626C6F636B2D7363756C6B2D636174616C7973742D66616C6C18 +626C6F636B2D7363756C6B2D636174616C7973742D6869741A626C6F636B2D7363756C6B2D6361 +74616C7973742D706C61636519626C6F636B2D7363756C6B2D636174616C7973742D737465701B +626C6F636B2D7363756C6B2D73656E736F722D636C69636B696E6720626C6F636B2D7363756C6B +2D73656E736F722D636C69636B696E672D73746F7018626C6F636B2D7363756C6B2D73656E736F +722D627265616B17626C6F636B2D7363756C6B2D73656E736F722D66616C6C16626C6F636B2D73 +63756C6B2D73656E736F722D68697418626C6F636B2D7363756C6B2D73656E736F722D706C6163 +6517626C6F636B2D7363756C6B2D73656E736F722D737465701A626C6F636B2D7363756C6B2D73 +687269656B65722D627265616B19626C6F636B2D7363756C6B2D73687269656B65722D66616C6C +18626C6F636B2D7363756C6B2D73687269656B65722D6869741A626C6F636B2D7363756C6B2D73 +687269656B65722D706C6163651B626C6F636B2D7363756C6B2D73687269656B65722D73687269 +656B19626C6F636B2D7363756C6B2D73687269656B65722D7374657016626C6F636B2D7363756C +6B2D7665696E2D627265616B15626C6F636B2D7363756C6B2D7665696E2D66616C6C14626C6F63 +6B2D7363756C6B2D7665696E2D68697416626C6F636B2D7363756C6B2D7665696E2D706C616365 +15626C6F636B2D7363756C6B2D7665696E2D7374657014656E746974792D73686565702D616D62 +69656E7412656E746974792D73686565702D646561746811656E746974792D73686565702D6875 +727412656E746974792D73686565702D736865617211656E746974792D73686565702D73746570 +106974656D2D7368656172732D736E697014626C6F636B2D7368656C662D616374697661746511 +626C6F636B2D7368656C662D627265616B16626C6F636B2D7368656C662D646561637469766174 +6510626C6F636B2D7368656C662D66616C6C0F626C6F636B2D7368656C662D68697416626C6F63 +6B2D7368656C662D6D756C74692D7377617011626C6F636B2D7368656C662D706C61636516626C +6F636B2D7368656C662D706C6163652D6974656D17626C6F636B2D7368656C662D73696E676C65 +2D7377617010626C6F636B2D7368656C662D7374657015626C6F636B2D7368656C662D74616B65 +2D6974656D116974656D2D736869656C642D626C6F636B116974656D2D736869656C642D627265 +616B17626C6F636B2D7368726F6F6D6C696768742D627265616B16626C6F636B2D7368726F6F6D +6C696768742D7374657017626C6F636B2D7368726F6F6D6C696768742D706C61636515626C6F63 +6B2D7368726F6F6D6C696768742D68697416626C6F636B2D7368726F6F6D6C696768742D66616C +6C136974656D2D73686F76656C2D666C617474656E16656E746974792D7368756C6B65722D616D +6269656E7417626C6F636B2D7368756C6B65722D626F782D636C6F736516626C6F636B2D736875 +6C6B65722D626F782D6F70656E19656E746974792D7368756C6B65722D62756C6C65742D686974 +1A656E746974792D7368756C6B65722D62756C6C65742D6875727414656E746974792D7368756C +6B65722D636C6F736514656E746974792D7368756C6B65722D646561746813656E746974792D73 +68756C6B65722D687572741A656E746974792D7368756C6B65722D687572742D636C6F73656413 +656E746974792D7368756C6B65722D6F70656E14656E746974792D7368756C6B65722D73686F6F +7417656E746974792D7368756C6B65722D74656C65706F727419656E746974792D73696C766572 +666973682D616D6269656E7417656E746974792D73696C766572666973682D646561746816656E +746974792D73696C766572666973682D6875727416656E746974792D73696C766572666973682D +7374657017656E746974792D736B656C65746F6E2D616D6269656E7422656E746974792D736B65 +6C65746F6E2D636F6E7665727465642D746F2D737472617915656E746974792D736B656C65746F +6E2D64656174681D656E746974792D736B656C65746F6E2D686F7273652D616D6269656E741B65 +6E746974792D736B656C65746F6E2D686F7273652D64656174681A656E746974792D736B656C65 +746F6E2D686F7273652D687572741A656E746974792D736B656C65746F6E2D686F7273652D7377 +696D23656E746974792D736B656C65746F6E2D686F7273652D616D6269656E742D776174657222 +656E746974792D736B656C65746F6E2D686F7273652D67616C6C6F702D776174657220656E7469 +74792D736B656C65746F6E2D686F7273652D6A756D702D776174657220656E746974792D736B65 +6C65746F6E2D686F7273652D737465702D776174657214656E746974792D736B656C65746F6E2D +6875727415656E746974792D736B656C65746F6E2D73686F6F7414656E746974792D736B656C65 +746F6E2D7374657013656E746974792D736C696D652D61747461636B12656E746974792D736C69 +6D652D646561746811656E746974792D736C696D652D6875727411656E746974792D736C696D65 +2D6A756D7013656E746974792D736C696D652D73717569736817626C6F636B2D736C696D652D62 +6C6F636B2D627265616B16626C6F636B2D736C696D652D626C6F636B2D66616C6C15626C6F636B +2D736C696D652D626C6F636B2D68697417626C6F636B2D736C696D652D626C6F636B2D706C6163 +6516626C6F636B2D736C696D652D626C6F636B2D737465701E626C6F636B2D736D616C6C2D616D +6574687973742D6275642D627265616B1E626C6F636B2D736D616C6C2D616D6574687973742D62 +75642D706C6163651A626C6F636B2D736D616C6C2D647269706C6561662D627265616B19626C6F +636B2D736D616C6C2D647269706C6561662D66616C6C18626C6F636B2D736D616C6C2D64726970 +6C6561662D6869741A626C6F636B2D736D616C6C2D647269706C6561662D706C61636519626C6F +636B2D736D616C6C2D647269706C6561662D7374657015626C6F636B2D736F756C2D73616E642D +627265616B14626C6F636B2D736F756C2D73616E642D7374657015626C6F636B2D736F756C2D73 +616E642D706C61636513626C6F636B2D736F756C2D73616E642D68697414626C6F636B2D736F75 +6C2D73616E642D66616C6C15626C6F636B2D736F756C2D736F696C2D627265616B14626C6F636B +2D736F756C2D736F696C2D7374657015626C6F636B2D736F756C2D736F696C2D706C6163651362 +6C6F636B2D736F756C2D736F696C2D68697414626C6F636B2D736F756C2D736F696C2D66616C6C +147061727469636C652D736F756C2D65736361706513626C6F636B2D737061776E65722D627265 +616B12626C6F636B2D737061776E65722D66616C6C11626C6F636B2D737061776E65722D686974 +13626C6F636B2D737061776E65722D706C61636512626C6F636B2D737061776E65722D73746570 +0E6974656D2D73706561722D7573650E6974656D2D73706561722D686974116974656D2D737065 +61722D61747461636B136974656D2D73706561722D776F6F642D757365136974656D2D73706561 +722D776F6F642D686974166974656D2D73706561722D776F6F642D61747461636B19626C6F636B +2D73706F72652D626C6F73736F6D2D627265616B18626C6F636B2D73706F72652D626C6F73736F +6D2D66616C6C17626C6F636B2D73706F72652D626C6F73736F6D2D68697419626C6F636B2D7370 +6F72652D626C6F73736F6D2D706C61636518626C6F636B2D73706F72652D626C6F73736F6D2D73 +74657016656E746974792D737472696465722D616D6269656E7414656E746974792D7374726964 +65722D686170707916656E746974792D737472696465722D7265747265617414656E746974792D +737472696465722D646561746813656E746974792D737472696465722D6875727413656E746974 +792D737472696465722D7374657018656E746974792D737472696465722D737465702D6C617661 +12656E746974792D737472696465722D65617415656E746974792D737472696465722D73616464 +6C6518656E746974792D736C696D652D64656174682D736D616C6C17656E746974792D736C696D +652D687572742D736D616C6C17656E746974792D736C696D652D6A756D702D736D616C6C19656E +746974792D736C696D652D7371756973682D736D616C6C18626C6F636B2D736D697468696E672D +7461626C652D75736512626C6F636B2D736D6F6B65722D736D6F6B6513656E746974792D736E69 +666665722D7374657012656E746974792D736E69666665722D65617413656E746974792D736E69 +666665722D69646C6513656E746974792D736E69666665722D6875727414656E746974792D736E +69666665722D646561746818656E746974792D736E69666665722D64726F702D7365656417656E +746974792D736E69666665722D7363656E74696E6717656E746974792D736E69666665722D736E +696666696E6718656E746974792D736E69666665722D736561726368696E6716656E746974792D +736E69666665722D64696767696E671B656E746974792D736E69666665722D64696767696E672D +73746F7014656E746974792D736E69666665722D686170707916626C6F636B2D736E6966666572 +2D6567672D706C6F7017626C6F636B2D736E69666665722D6567672D637261636B17626C6F636B +2D736E69666665722D6567672D686174636815656E746974792D736E6F7762616C6C2D7468726F +7710626C6F636B2D736E6F772D627265616B0F626C6F636B2D736E6F772D66616C6C19656E7469 +74792D736E6F772D676F6C656D2D616D6269656E7417656E746974792D736E6F772D676F6C656D +2D646561746816656E746974792D736E6F772D676F6C656D2D6875727417656E746974792D736E +6F772D676F6C656D2D73686F6F7417656E746974792D736E6F772D676F6C656D2D73686561720E +626C6F636B2D736E6F772D68697410626C6F636B2D736E6F772D706C6163650F626C6F636B2D73 +6E6F772D7374657015656E746974792D7370696465722D616D6269656E7413656E746974792D73 +70696465722D646561746812656E746974792D7370696465722D6875727412656E746974792D73 +70696465722D737465701A656E746974792D73706C6173682D706F74696F6E2D627265616B1A65 +6E746974792D73706C6173682D706F74696F6E2D7468726F7712626C6F636B2D73706F6E67652D +627265616B11626C6F636B2D73706F6E67652D66616C6C10626C6F636B2D73706F6E67652D6869 +7412626C6F636B2D73706F6E67652D706C61636511626C6F636B2D73706F6E67652D7374657013 +626C6F636B2D73706F6E67652D6162736F7262116974656D2D737079676C6173732D7573651869 +74656D2D737079676C6173732D73746F702D7573696E6714656E746974792D73717569642D616D +6269656E7412656E746974792D73717569642D646561746811656E746974792D73717569642D68 +75727413656E746974792D73717569642D73717569727411626C6F636B2D73746F6E652D627265 +616B1C626C6F636B2D73746F6E652D627574746F6E2D636C69636B2D6F66661B626C6F636B2D73 +746F6E652D627574746F6E2D636C69636B2D6F6E10626C6F636B2D73746F6E652D66616C6C0F62 +6C6F636B2D73746F6E652D68697411626C6F636B2D73746F6E652D706C61636524626C6F636B2D +73746F6E652D70726573737572652D706C6174652D636C69636B2D6F666623626C6F636B2D7374 +6F6E652D70726573737572652D706C6174652D636C69636B2D6F6E10626C6F636B2D73746F6E65 +2D7374657014656E746974792D73747261792D616D6269656E7412656E746974792D7374726179 +2D646561746811656E746974792D73747261792D6875727411656E746974792D73747261792D73 +74657018626C6F636B2D73756C6675722D7370696B652D627265616B17626C6F636B2D73756C66 +75722D7370696B652D7374657018626C6F636B2D73756C6675722D7370696B652D706C61636516 +626C6F636B2D73756C6675722D7370696B652D68697417626C6F636B2D73756C6675722D737069 +6B652D66616C6C17626C6F636B2D73756C6675722D7370696B652D6C616E641C626C6F636B2D73 +776565742D62657272792D627573682D627265616B1C626C6F636B2D73776565742D6265727279 +2D627573682D706C61636523626C6F636B2D73776565742D62657272792D627573682D7069636B +2D6265727269657314656E746974792D746164706F6C652D646561746813656E746974792D7461 +64706F6C652D666C6F7016656E746974792D746164706F6C652D67726F772D757013656E746974 +792D746164706F6C652D6875727412656E6368616E742D74686F726E732D68697411656E746974 +792D746E742D7072696D65640E6974656D2D746F74656D2D757365106974656D2D74726964656E +742D686974176974656D2D74726964656E742D6869742D67726F756E64136974656D2D74726964 +656E742D72657475726E166974656D2D74726964656E742D726970746964652D31166974656D2D +74726964656E742D726970746964652D32166974656D2D74726964656E742D726970746964652D +33126974656D2D74726964656E742D7468726F77146974656D2D74726964656E742D7468756E64 +657215626C6F636B2D74726970776972652D61747461636818626C6F636B2D7472697077697265 +2D636C69636B2D6F666617626C6F636B2D74726970776972652D636C69636B2D6F6E15626C6F63 +6B2D74726970776972652D6465746163681C656E746974792D74726F706963616C2D666973682D +616D6269656E741A656E746974792D74726F706963616C2D666973682D646561746819656E7469 +74792D74726F706963616C2D666973682D666C6F7019656E746974792D74726F706963616C2D66 +6973682D6875727410626C6F636B2D747566662D627265616B0F626C6F636B2D747566662D7374 +657010626C6F636B2D747566662D706C6163650E626C6F636B2D747566662D6869740F626C6F63 +6B2D747566662D66616C6C17626C6F636B2D747566662D627269636B732D627265616B16626C6F +636B2D747566662D627269636B732D66616C6C15626C6F636B2D747566662D627269636B732D68 +697417626C6F636B2D747566662D627269636B732D706C61636516626C6F636B2D747566662D62 +7269636B732D7374657019626C6F636B2D706F6C69736865642D747566662D627265616B18626C +6F636B2D706F6C69736865642D747566662D66616C6C17626C6F636B2D706F6C69736865642D74 +7566662D68697419626C6F636B2D706F6C69736865642D747566662D706C61636518626C6F636B +2D706F6C69736865642D747566662D737465701A656E746974792D747572746C652D616D626965 +6E742D6C616E6413656E746974792D747572746C652D646561746818656E746974792D74757274 +6C652D64656174682D6261627917656E746974792D747572746C652D6567672D627265616B1765 +6E746974792D747572746C652D6567672D637261636B17656E746974792D747572746C652D6567 +672D686174636812656E746974792D747572746C652D6875727417656E746974792D747572746C +652D687572742D6261627915656E746974792D747572746C652D6C61792D65676715656E746974 +792D747572746C652D7368616D626C651A656E746974792D747572746C652D7368616D626C652D +6261627912656E746974792D747572746C652D7377696D0F75692D627574746F6E2D636C69636B +1675692D6C6F6F6D2D73656C6563742D7061747465726E1375692D6C6F6F6D2D74616B652D7265 +73756C742075692D636172746F6772617068792D7461626C652D74616B652D726573756C741A75 +692D73746F6E656375747465722D74616B652D726573756C741C75692D73746F6E656375747465 +722D73656C6563742D7265636970651B75692D746F6173742D6368616C6C656E67652D636F6D70 +6C6574650B75692D746F6173742D696E0C75692D746F6173742D6F757414626C6F636B2D766175 +6C742D616374697661746513626C6F636B2D7661756C742D616D6269656E7411626C6F636B2D76 +61756C742D627265616B19626C6F636B2D7661756C742D636C6F73652D7368757474657216626C +6F636B2D7661756C742D6465616374697661746516626C6F636B2D7661756C742D656A6563742D +6974656D22626C6F636B2D7661756C742D72656A6563742D72657761726465642D706C61796572 +10626C6F636B2D7661756C742D66616C6C0F626C6F636B2D7661756C742D68697417626C6F636B +2D7661756C742D696E736572742D6974656D1C626C6F636B2D7661756C742D696E736572742D69 +74656D2D6661696C18626C6F636B2D7661756C742D6F70656E2D7368757474657211626C6F636B +2D7661756C742D706C61636510626C6F636B2D7661756C742D7374657012656E746974792D7665 +782D616D6269656E7411656E746974792D7665782D63686172676510656E746974792D7665782D +64656174680F656E746974792D7665782D6875727417656E746974792D76696C6C616765722D61 +6D6269656E7419656E746974792D76696C6C616765722D63656C65627261746515656E74697479 +2D76696C6C616765722D646561746814656E746974792D76696C6C616765722D6875727412656E +746974792D76696C6C616765722D6E6F15656E746974792D76696C6C616765722D747261646513 +656E746974792D76696C6C616765722D7965731C656E746974792D76696C6C616765722D776F72 +6B2D61726D6F7265721C656E746974792D76696C6C616765722D776F726B2D6275746368657221 +656E746974792D76696C6C616765722D776F726B2D636172746F677261706865721B656E746974 +792D76696C6C616765722D776F726B2D636C657269631B656E746974792D76696C6C616765722D +776F726B2D6661726D65721E656E746974792D76696C6C616765722D776F726B2D666973686572 +6D616E1D656E746974792D76696C6C616765722D776F726B2D666C65746368657222656E746974 +792D76696C6C616765722D776F726B2D6C656174686572776F726B65721E656E746974792D7669 +6C6C616765722D776F726B2D6C696272617269616E1A656E746974792D76696C6C616765722D77 +6F726B2D6D61736F6E1D656E746974792D76696C6C616765722D776F726B2D7368657068657264 +1E656E746974792D76696C6C616765722D776F726B2D746F6F6C736D69746820656E746974792D +76696C6C616765722D776F726B2D776561706F6E736D69746819656E746974792D76696E646963 +61746F722D616D6269656E741B656E746974792D76696E64696361746F722D63656C6562726174 +6517656E746974792D76696E64696361746F722D646561746816656E746974792D76696E646963 +61746F722D6875727410626C6F636B2D76696E652D627265616B0F626C6F636B2D76696E652D66 +616C6C0E626C6F636B2D76696E652D68697410626C6F636B2D76696E652D706C6163650F626C6F +636B2D76696E652D7374657014626C6F636B2D6C696C792D7061642D706C6163651F656E746974 +792D77616E646572696E672D7472616465722D616D6269656E741D656E746974792D77616E6465 +72696E672D7472616465722D646561746823656E746974792D77616E646572696E672D74726164 +65722D646973617070656172656422656E746974792D77616E646572696E672D7472616465722D +6472696E6B2D6D696C6B24656E746974792D77616E646572696E672D7472616465722D6472696E +6B2D706F74696F6E1C656E746974792D77616E646572696E672D7472616465722D687572741A65 +6E746974792D77616E646572696E672D7472616465722D6E6F22656E746974792D77616E646572 +696E672D7472616465722D726561707065617265641D656E746974792D77616E646572696E672D +7472616465722D74726164651B656E746974792D77616E646572696E672D7472616465722D7965 +7316656E746974792D77617264656E2D616769746174656415656E746974792D77617264656E2D +616D6269656E7413656E746974792D77617264656E2D616E6772791B656E746974792D77617264 +656E2D61747461636B2D696D7061637413656E746974792D77617264656E2D646561746811656E +746974792D77617264656E2D64696714656E746974792D77617264656E2D656D6572676517656E +746974792D77617264656E2D68656172746265617412656E746974792D77617264656E2D687572 +7417656E746974792D77617264656E2D6C697374656E696E671D656E746974792D77617264656E +2D6C697374656E696E672D616E6772791A656E746974792D77617264656E2D6E65617262792D63 +6C6F73651B656E746974792D77617264656E2D6E65617262792D636C6F7365721C656E74697479 +2D77617264656E2D6E65617262792D636C6F7365737412656E746974792D77617264656E2D726F +617213656E746974792D77617264656E2D736E69666618656E746974792D77617264656E2D736F +6E69632D626F6F6D1A656E746974792D77617264656E2D736F6E69632D63686172676512656E74 +6974792D77617264656E2D737465701C656E746974792D77617264656E2D74656E6472696C2D63 +6C69636B7326626C6F636B2D68616E67696E672D7369676E2D77617865642D696E746572616374 +2D6661696C1E626C6F636B2D7369676E2D77617865642D696E7465726163742D6661696C13626C +6F636B2D77617465722D616D6269656E7411776561746865722D656E642D666C6173680C776561 +746865722D7261696E12776561746865722D7261696E2D61626F766515626C6F636B2D7765742D +67726173732D627265616B14626C6F636B2D7765742D67726173732D66616C6C13626C6F636B2D +7765742D67726173732D68697415626C6F636B2D7765742D67726173732D706C61636514626C6F +636B2D7765742D67726173732D7374657016626C6F636B2D7765742D73706F6E67652D62726561 +6B16626C6F636B2D7765742D73706F6E67652D647269657315626C6F636B2D7765742D73706F6E +67652D66616C6C14626C6F636B2D7765742D73706F6E67652D68697416626C6F636B2D7765742D +73706F6E67652D706C61636515626C6F636B2D7765742D73706F6E67652D737465701D656E7469 +74792D77696E642D6368617267652D77696E642D627572737418656E746974792D77696E642D63 +68617267652D7468726F7714656E746974792D77697463682D616D6269656E7416656E74697479 +2D77697463682D63656C65627261746512656E746974792D77697463682D646561746812656E74 +6974792D77697463682D6472696E6B11656E746974792D77697463682D6875727412656E746974 +792D77697463682D7468726F7715656E746974792D7769746865722D616D6269656E7419656E74 +6974792D7769746865722D627265616B2D626C6F636B13656E746974792D7769746865722D6465 +61746812656E746974792D7769746865722D6875727413656E746974792D7769746865722D7368 +6F6F741E656E746974792D7769746865722D736B656C65746F6E2D616D6269656E741C656E7469 +74792D7769746865722D736B656C65746F6E2D64656174681B656E746974792D7769746865722D +736B656C65746F6E2D687572741B656E746974792D7769746865722D736B656C65746F6E2D7374 +657013656E746974792D7769746865722D737061776E156974656D2D776F6C662D61726D6F722D +627265616B18656E746974792D626162792D776F6C662D616D6269656E74156974656D2D776F6C +662D61726D6F722D637261636B166974656D2D776F6C662D61726D6F722D64616D616765166974 +656D2D776F6C662D61726D6F722D72657061697216656E746974792D626162792D776F6C662D64 +6561746816656E746974792D626162792D776F6C662D67726F776C15656E746974792D62616279 +2D776F6C662D6875727415656E746974792D626162792D776F6C662D70616E7411656E74697479 +2D776F6C662D7368616B6510656E746974792D776F6C662D7374657015656E746974792D626162 +792D776F6C662D7374657016656E746974792D626162792D776F6C662D7768696E6513656E7469 +74792D776F6C662D616D6269656E7411656E746974792D776F6C662D646561746811656E746974 +792D776F6C662D67726F776C10656E746974792D776F6C662D6875727410656E746974792D776F +6C662D70616E7411656E746974792D776F6C662D7768696E651A656E746974792D776F6C662D70 +75676C696E2D616D6269656E7418656E746974792D776F6C662D7075676C696E2D646561746818 +656E746974792D776F6C662D7075676C696E2D67726F776C17656E746974792D776F6C662D7075 +676C696E2D6875727417656E746974792D776F6C662D7075676C696E2D70616E7418656E746974 +792D776F6C662D7075676C696E2D7768696E6517656E746974792D776F6C662D7361642D616D62 +69656E7415656E746974792D776F6C662D7361642D646561746815656E746974792D776F6C662D +7361642D67726F776C14656E746974792D776F6C662D7361642D6875727414656E746974792D77 +6F6C662D7361642D70616E7415656E746974792D776F6C662D7361642D7768696E6519656E7469 +74792D776F6C662D616E6772792D616D6269656E7417656E746974792D776F6C662D616E677279 +2D646561746817656E746974792D776F6C662D616E6772792D67726F776C16656E746974792D77 +6F6C662D616E6772792D6875727416656E746974792D776F6C662D616E6772792D70616E741765 +6E746974792D776F6C662D616E6772792D7768696E651A656E746974792D776F6C662D6772756D +70792D616D6269656E7418656E746974792D776F6C662D6772756D70792D646561746818656E74 +6974792D776F6C662D6772756D70792D67726F776C17656E746974792D776F6C662D6772756D70 +792D6875727417656E746974792D776F6C662D6772756D70792D70616E7418656E746974792D77 +6F6C662D6772756D70792D7768696E6517656E746974792D776F6C662D6269672D616D6269656E +7415656E746974792D776F6C662D6269672D646561746815656E746974792D776F6C662D626967 +2D67726F776C14656E746974792D776F6C662D6269672D6875727414656E746974792D776F6C66 +2D6269672D70616E7415656E746974792D776F6C662D6269672D7768696E6518656E746974792D +776F6C662D637574652D616D6269656E7416656E746974792D776F6C662D637574652D64656174 +6816656E746974792D776F6C662D637574652D67726F776C15656E746974792D776F6C662D6375 +74652D6875727415656E746974792D776F6C662D637574652D70616E7416656E746974792D776F +6C662D637574652D7768696E6517626C6F636B2D776F6F64656E2D646F6F722D636C6F73651662 +6C6F636B2D776F6F64656E2D646F6F722D6F70656E1B626C6F636B2D776F6F64656E2D74726170 +646F6F722D636C6F73651A626C6F636B2D776F6F64656E2D74726170646F6F722D6F70656E1D62 +6C6F636B2D776F6F64656E2D627574746F6E2D636C69636B2D6F66661C626C6F636B2D776F6F64 +656E2D627574746F6E2D636C69636B2D6F6E25626C6F636B2D776F6F64656E2D70726573737572 +652D706C6174652D636C69636B2D6F666624626C6F636B2D776F6F64656E2D7072657373757265 +2D706C6174652D636C69636B2D6F6E10626C6F636B2D776F6F642D627265616B0F626C6F636B2D +776F6F642D66616C6C0E626C6F636B2D776F6F642D68697410626C6F636B2D776F6F642D706C61 +63650F626C6F636B2D776F6F642D7374657010626C6F636B2D776F6F6C2D627265616B0F626C6F +636B2D776F6F6C2D66616C6C0E626C6F636B2D776F6F6C2D68697410626C6F636B2D776F6F6C2D +706C6163650F626C6F636B2D776F6F6C2D7374657015656E746974792D7A6F676C696E2D616D62 +69656E7413656E746974792D7A6F676C696E2D616E67727914656E746974792D7A6F676C696E2D +61747461636B13656E746974792D7A6F676C696E2D646561746812656E746974792D7A6F676C69 +6E2D6875727412656E746974792D7A6F676C696E2D7374657015656E746974792D7A6F6D626965 +2D616D6269656E7420656E746974792D7A6F6D6269652D61747461636B2D776F6F64656E2D646F +6F721E656E746974792D7A6F6D6269652D61747461636B2D69726F6E2D646F6F721F656E746974 +792D7A6F6D6269652D627265616B2D776F6F64656E2D646F6F7222656E746974792D7A6F6D6269 +652D636F6E7665727465642D746F2D64726F776E656413656E746974792D7A6F6D6269652D6465 +61746819656E746974792D7A6F6D6269652D64657374726F792D6567671B656E746974792D7A6F +6D6269652D686F7273652D616D6269656E7419656E746974792D7A6F6D6269652D686F7273652D +616E67727919656E746974792D7A6F6D6269652D686F7273652D646561746817656E746974792D +7A6F6D6269652D686F7273652D65617418656E746974792D7A6F6D6269652D686F7273652D6875 +727412656E746974792D7A6F6D6269652D6875727414656E746974792D7A6F6D6269652D696E66 +6563741E656E746974792D7A6F6D6269652D6E617574696C75732D616D6269656E7423656E7469 +74792D7A6F6D6269652D6E617574696C75732D616D6269656E742D6C616E641B656E746974792D +7A6F6D6269652D6E617574696C75732D6461736820656E746974792D7A6F6D6269652D6E617574 +696C75732D646173682D6C616E6421656E746974792D7A6F6D6269652D6E617574696C75732D64 +6173682D726561647926656E746974792D7A6F6D6269652D6E617574696C75732D646173682D72 +656164792D6C616E641C656E746974792D7A6F6D6269652D6E617574696C75732D646561746821 +656E746974792D7A6F6D6269652D6E617574696C75732D64656174682D6C616E641A656E746974 +792D7A6F6D6269652D6E617574696C75732D6561741B656E746974792D7A6F6D6269652D6E6175 +74696C75732D6875727420656E746974792D7A6F6D6269652D6E617574696C75732D687572742D +6C616E641B656E746974792D7A6F6D6269652D6E617574696C75732D7377696D1F656E74697479 +2D7A6F6D6269666965642D7069676C696E2D616D6269656E741D656E746974792D7A6F6D626966 +6965642D7069676C696E2D616E6772791D656E746974792D7A6F6D6269666965642D7069676C69 +6E2D64656174681C656E746974792D7A6F6D6269666965642D7069676C696E2D6875727412656E +746974792D7A6F6D6269652D737465701E656E746974792D7A6F6D6269652D76696C6C61676572 +2D616D6269656E7420656E746974792D7A6F6D6269652D76696C6C616765722D636F6E76657274 +65641B656E746974792D7A6F6D6269652D76696C6C616765722D637572651C656E746974792D7A +6F6D6269652D76696C6C616765722D64656174681B656E746974792D7A6F6D6269652D76696C6C +616765722D687572741B656E746974792D7A6F6D6269652D76696C6C616765722D737465701965 +76656E742D6D6F622D6566666563742D6261642D6F6D656E1B6576656E742D6D6F622D65666665 +63742D747269616C2D6F6D656E1A6576656E742D6D6F622D6566666563742D726169642D6F6D65 +6E136974656D2D736164646C652D756E6571756970256974656D2D6E617574696C75732D736164 +646C652D756E64657277617465722D65717569701A6974656D2D6E617574696C75732D73616464 +6C652D657175697012626C6F636B2D73756C6675722D627265616B11626C6F636B2D73756C6675 +722D7374657012626C6F636B2D73756C6675722D706C61636510626C6F636B2D73756C6675722D +68697411626C6F636B2D73756C6675722D66616C6C19626C6F636B2D706F74656E742D73756C66 +75722D627265616B18626C6F636B2D706F74656E742D73756C6675722D7374657019626C6F636B +2D706F74656E742D73756C6675722D706C61636517626C6F636B2D706F74656E742D73756C6675 +722D68697418626C6F636B2D706F74656E742D73756C6675722D66616C6C23626C6F636B2D706F +74656E742D73756C6675722D6765797365722D6572757074696F6E2A626C6F636B2D706F74656E +742D73756C6675722D6765797365722D6572757074696F6E2D6163746976652E626C6F636B2D70 +6F74656E742D73756C6675722D6765797365722D636F6E74696E756F75732D6572757074696F6E +35626C6F636B2D706F74656E742D73756C6675722D6765797365722D636F6E74696E756F75732D +6572757074696F6E2D61637469766514626C6F636B2D63696E6E616261722D627265616B13626C +6F636B2D63696E6E616261722D7374657014626C6F636B2D63696E6E616261722D706C61636512 +626C6F636B2D63696E6E616261722D68697413626C6F636B2D63696E6E616261722D66616C6C19 +656E746974792D73756C6675722D637562652D6162736F726219656E746974792D73756C667572 +2D637562652D626F756E636518656E746974792D73756C6675722D637562652D64656174681865 +6E746974792D73756C6675722D637562652D656A65637417656E746974792D73756C6675722D63 +7562652D6875727417656E746974792D73756C6675722D637562652D6A756D701E656E74697479 +2D73756C6675722D637562652D726567756C61722D6869741F656E746974792D73756C6675722D +637562652D726567756C61722D707573681D656E746974792D73756C6675722D637562652D626F +756E63792D6869741E656E746974792D73756C6675722D637562652D626F756E63792D70757368 +22656E746974792D73756C6675722D637562652D736C6F772D626F756E63792D68697423656E74 +6974792D73756C6675722D637562652D736C6F772D626F756E63792D7075736820656E74697479 +2D73756C6675722D637562652D736C6F772D666C61742D68697421656E746974792D73756C6675 +722D637562652D736C6F772D666C61742D7075736820656E746974792D73756C6675722D637562 +652D666173742D666C61742D68697421656E746974792D73756C6675722D637562652D66617374 +2D666C61742D707573681C656E746974792D73756C6675722D637562652D6C696768742D686974 +1D656E746974792D73756C6675722D637562652D6C696768742D7075736823656E746974792D73 +756C6675722D637562652D666173742D736C6964696E672D68697424656E746974792D73756C66 +75722D637562652D666173742D736C6964696E672D7075736823656E746974792D73756C667572 +2D637562652D736C6F772D736C6964696E672D68697424656E746974792D73756C6675722D6375 +62652D736C6F772D736C6964696E672D707573681D656E746974792D73756C6675722D63756265 +2D737469636B792D6869741E656E746974792D73756C6675722D637562652D737469636B792D70 +75736826656E746974792D73756C6675722D637562652D686967682D726573697374616E63652D +68697427656E746974792D73756C6675722D637562652D686967682D726573697374616E63652D +7075736820656E746974792D73756C6675722D637562652D6578706C6F736976652D6869742165 +6E746974792D73756C6675722D637562652D6578706C6F736976652D707573681A656E74697479 +2D73756C6675722D637562652D686F742D6869741B656E746974792D73756C6675722D63756265 +2D686F742D7075736819656E746974792D73756C6675722D637562652D7371756973681F626C6F +636B2D706F74656E742D73756C6675722D6E6F78696F75732D6761731E656E746974792D736D61 +6C6C2D73756C6675722D637562652D64656174681D656E746974792D736D616C6C2D73756C6675 +722D637562652D687572741D656E746974792D736D616C6C2D73756C6675722D637562652D6A75 +6D701F656E746974792D736D616C6C2D73756C6675722D637562652D7371756973681C656E7469 +74792D736D616C6C2D73756C6675722D637562652D656174040005736F756E6403000203001B70 +756D706B696E3A706C7567696E2F736F756E647340302E312E30051F014202016D9E010B616361 +6369612D626F6174116163616369612D63686573742D626F617405616C6C617911617265612D65 +66666563742D636C6F75640961726D6164696C6C6F0B61726D6F722D7374616E64056172726F77 +0761786F6C6F746C1162616D626F6F2D63686573742D726166740B62616D626F6F2D7261667403 +626174036265650A62697263682D626F61741062697263682D63686573742D626F617405626C61 +7A650D626C6F636B2D646973706C617906626F6767656406627265657A6512627265657A652D77 +696E642D6368617267650563616D656C0A63616D656C2D6875736B036361740B636176652D7370 +696465720B6368657272792D626F6174116368657272792D63686573742D626F61740E63686573 +742D6D696E656361727407636869636B656E03636F6416636F6D6D616E642D626C6F636B2D6D69 +6E65636172740C636F707065722D676F6C656D03636F7708637265616B696E6707637265657065 +720D6461726B2D6F616B2D626F6174136461726B2D6F616B2D63686573742D626F617407646F6C +7068696E06646F6E6B65790F647261676F6E2D6669726562616C6C0764726F776E656403656767 +0E656C6465722D677561726469616E0B656E642D6372797374616C0C656E6465722D647261676F +6E0B656E6465722D706561726C08656E6465726D616E09656E6465726D6974650665766F6B6572 +0C65766F6B65722D66616E677311657870657269656E63652D626F74746C650E65787065726965 +6E63652D6F72620C6579652D6F662D656E6465720D66616C6C696E672D626C6F636B0866697265 +62616C6C0F66697265776F726B2D726F636B65740E66697368696E672D626F6262657203666F78 +0466726F67106675726E6163652D6D696E6563617274056768617374056769616E740F676C6F77 +2D6974656D2D6672616D650A676C6F772D737175696404676F617408677561726469616E0B6861 +7070792D676861737406686F676C696E0F686F707065722D6D696E656361727405686F72736504 +6875736B0A696C6C7573696F6E65720B696E746572616374696F6E0A69726F6E2D676F6C656D04 +6974656D0C6974656D2D646973706C61790A6974656D2D6672616D650B6A756E676C652D626F61 +74116A756E676C652D63686573742D626F61740A6C656173682D6B6E6F740E6C696768746E696E +672D626F6C74106C696E676572696E672D706F74696F6E056C6C616D610A6C6C616D612D737069 +740A6D61676D612D637562650D6D616E67726F76652D626F6174136D616E67726F76652D636865 +73742D626F6174096D616E6E657175696E066D61726B6572086D696E6563617274096D6F6F7368 +726F6F6D046D756C65086E617574696C7573086F616B2D626F61740E6F616B2D63686573742D62 +6F6174066F63656C6F74146F6D696E6F75732D6974656D2D737061776E6572087061696E74696E +670D70616C652D6F616B2D626F61741370616C652D6F616B2D63686573742D626F61740570616E +6461077061726368656406706172726F74077068616E746F6D03706967067069676C696E0C7069 +676C696E2D62727574650870696C6C6167657206706C617965720A706F6C61722D626561720A70 +7566666572666973680672616262697407726176616765720673616C6D6F6E0573686565700773 +68756C6B65720E7368756C6B65722D62756C6C65740A73696C7665726669736808736B656C6574 +6F6E0E736B656C65746F6E2D686F72736505736C696D650E736D616C6C2D6669726562616C6C07 +736E69666665720A736E6F772D676F6C656D08736E6F7762616C6C10737061776E65722D6D696E +65636172740E737065637472616C2D6172726F77067370696465720D73706C6173682D706F7469 +6F6E0B7370727563652D626F6174117370727563652D63686573742D626F617405737175696405 +737472617907737472696465720B73756C6675722D6375626507746164706F6C650C746578742D +646973706C617903746E740C746E742D6D696E65636172740C7472616465722D6C6C616D610774 +726964656E740D74726F706963616C2D6669736806747572746C65037665780876696C6C616765 +720A76696E64696361746F721077616E646572696E672D7472616465720677617264656E0B7769 +6E642D636861726765057769746368067769746865720F7769746865722D736B656C65746F6E0C +7769746865722D736B756C6C04776F6C66067A6F676C696E067A6F6D6269650C7A6F6D6269652D +686F7273650F7A6F6D6269652D6E617574696C75730F7A6F6D6269652D76696C6C61676572107A +6F6D6269666965642D7069676C696E04000B656E746974792D7479706503000003002170756D70 +6B696E3A706C7567696E2F656E746974792D747970657340302E312E300520014202016D420862 +61646C616E64730D62616D626F6F2D6A756E676C650D626173616C742D64656C74617305626561 +63680C62697263682D666F726573740C6368657272792D67726F76650A636F6C642D6F6365616E +0E6372696D736F6E2D666F726573740B6461726B2D666F726573740F646565702D636F6C642D6F +6365616E09646565702D6461726B11646565702D66726F7A656E2D6F6365616E13646565702D6C +756B657761726D2D6F6365616E0A646565702D6F6365616E066465736572740F6472697073746F +6E652D63617665730B656E642D62617272656E730D656E642D686967686C616E64730C656E642D +6D69646C616E64730F65726F6465642D6261646C616E64730D666C6F7765722D666F7265737406 +666F726573740C66726F7A656E2D6F6365616E0C66726F7A656E2D7065616B730C66726F7A656E +2D72697665720567726F76650A6963652D7370696B65730C6A61676765642D7065616B73066A75 +6E676C650E6C756B657761726D2D6F6365616E0A6C7573682D63617665730E6D616E67726F7665 +2D7377616D70066D6561646F770F6D757368726F6F6D2D6669656C64730D6E65746865722D7761 +73746573056F6365616E176F6C642D67726F7774682D62697263682D666F72657374156F6C642D +67726F7774682D70696E652D7461696761176F6C642D67726F7774682D7370727563652D746169 +67610B70616C652D67617264656E06706C61696E7305726976657207736176616E6E610F736176 +616E6E612D706C617465617511736D616C6C2D656E642D69736C616E64730B736E6F77792D6265 +6163680C736E6F77792D706C61696E730C736E6F77792D736C6F7065730B736E6F77792D746169 +676110736F756C2D73616E642D76616C6C65790D7370617273652D6A756E676C650B73746F6E79 +2D7065616B730B73746F6E792D73686F72650C73756C6675722D63617665731073756E666C6F77 +65722D706C61696E73057377616D70057461696761077468652D656E64087468652D766F69640A +7761726D2D6F6365616E0D7761727065642D666F726573741077696E6473776570742D666F7265 +73741877696E6473776570742D67726176656C6C792D68696C6C730F77696E6473776570742D68 +696C6C731177696E6473776570742D736176616E6E610F776F6F6465642D6261646C616E647304 +000562696F6D6503000003001B70756D706B696E3A706C7567696E2F62696F6D657340302E312E +300521014202016D33056172726F77116261642D7265737061776E2D706F696E74066361637475 +730863616D7066697265086372616D6D696E670D647261676F6E2D6272656174680564726F776E +076472792D6F75740B656E6465722D706561726C096578706C6F73696F6E0466616C6C0D66616C +6C696E672D616E76696C0D66616C6C696E672D626C6F636B1266616C6C696E672D7374616C6163 +74697465086669726562616C6C0966697265776F726B730D666C792D696E746F2D77616C6C0666 +7265657A650767656E657269630C67656E657269632D6B696C6C09686F742D666C6F6F7207696E +2D6669726507696E2D77616C6C0E696E6469726563742D6D61676963046C6176610E6C69676874 +6E696E672D626F6C740A6D6163652D736D617368056D616769630A6D6F622D61747461636B136D +6F622D61747461636B2D6E6F2D616767726F0E6D6F622D70726F6A656374696C65076F6E2D6669 +72650C6F75742D6F662D776F726C640E6F7574736964652D626F726465720D706C617965722D61 +747461636B10706C617965722D6578706C6F73696F6E0A736F6E69632D626F6F6D057370656172 +04737069740A7374616C61676D69746506737461727665057374696E670F73756C6675722D6375 +62652D686F741073776565742D62657272792D627573680674686F726E73067468726F776E0774 +726964656E7415756E617474726962757465642D6669726562616C6C0B77696E642D6368617267 +65067769746865720C7769746865722D736B756C6C04000B64616D6167652D7479706503000003 +002170756D706B696E3A706C7567696E2F64616D6167652D747970657340302E312E3005220142 +04016D3B0C616476616E63652D74696D650F616476616E63652D7765617468657223616C6C6F77 +2D656E746572696E672D6E65746865722D7573696E672D706F7274616C730B626C6F636B2D6472 +6F70731A626C6F636B2D6578706C6F73696F6E2D64726F702D646563617914636F6D6D616E642D +626C6F636B2D6F757470757413636F6D6D616E642D626C6F636B732D776F726B0F64726F776E69 +6E672D64616D61676515656C797472612D6D6F76656D656E742D636865636B1C656E6465722D70 +6561726C732D76616E6973682D6F6E2D64656174680C656E746974792D64726F70730B66616C6C +2D64616D6167650B666972652D64616D61676520666972652D7370726561642D7261646975732D +61726F756E642D706C6179657214666F72676976652D646561642D706C61796572730D66726565 +7A652D64616D61676513676C6F62616C2D736F756E642D6576656E747311696D6D656469617465 +2D7265737061776E0E6B6565702D696E76656E746F7279166C6176612D736F757263652D636F6E +76657273696F6E106C696D697465642D6372616674696E670B6C6F6361746F722D626172126C6F +672D61646D696E2D636F6D6D616E6473176D61782D626C6F636B2D6D6F64696669636174696F6E +73116D61782D636F6D6D616E642D666F726B731B6D61782D636F6D6D616E642D73657175656E63 +652D6C656E677468136D61782D656E746974792D6372616D6D696E67126D61782D6D696E656361 +72742D73706565641C6D61782D736E6F772D616363756D756C6174696F6E2D686569676874096D +6F622D64726F7073186D6F622D6578706C6F73696F6E2D64726F702D64656361790C6D6F622D67 +72696566696E671B6E61747572616C2D6865616C74682D726567656E65726174696F6E15706C61 +7965722D6D6F76656D656E742D636865636B24706C61796572732D6E65746865722D706F727461 +6C2D63726561746976652D64656C617923706C61796572732D6E65746865722D706F7274616C2D +64656661756C742D64656C61791B706C61796572732D736C656570696E672D70657263656E7461 +67651C70726F6A656374696C65732D63616E2D627265616B2D626C6F636B730370767005726169 +64731172616E646F6D2D7469636B2D737065656412726564756365642D64656275672D696E666F +0E7265737061776E2D7261646975731573656E642D636F6D6D616E642D666565646261636B1973 +686F772D616476616E63656D656E742D6D657373616765731373686F772D64656174682D6D6573 +73616765730A737061776E2D6D6F62730E737061776E2D6D6F6E73746572730D737061776E2D70 +6174726F6C730E737061776E2D7068616E746F6D7317737061776E2D77616E646572696E672D74 +7261646572730D737061776E2D77617264656E7313737061776E65722D626C6F636B732D776F72 +6B1A737065637461746F72732D67656E65726174652D6368756E6B730C7370726561642D76696E +65730C746E742D6578706C6F64657318746E742D6578706C6F73696F6E2D64726F702D64656361 +790F756E6976657273616C2D616E6765721777617465722D736F757263652D636F6E7665727369 +6F6E04000967616D652D72756C6503000001710203696E74017A0004626F6F6C017F0004000F67 +616D652D72756C652D76616C756503000203001F70756D706B696E3A706C7567696E2F67616D65 +2D72756C657340302E312E300523014209017202046869676877036C6F77770400047575696403 +0000014000000104000867656E65726174650102016B0101400101737300030400057061727365 +0104014001026964010073040009746F2D737472696E67010503001970756D706B696E3A706C75 +67696E2F7575696440302E312E3005240203000108706F736974696F6E020300010B656E746974 +792D706F73650203000B0C626C6F636B2D656E746974790203000B14636F6D6D616E642D626C6F +636B2D656E746974790203000B11626C6F636B2D656E746974792D747970650203000A0A73636F +7265626F6172640203000C087061727469636C650203000D05736F756E640203000D0E736F756E +642D63617465676F72790203000E0B656E746974792D747970650203000F0562696F6D65020300 +03126D6F6469666965722D6F7065726174696F6E020300100B64616D6167652D74797065020300 +110967616D652D72756C65020300110F67616D652D72756C652D76616C75650203001204757569 +640142E2040203020125040008706F736974696F6E030000020302012604000B656E746974792D +706F7365030002020302011C040009626C6F636B2D706F7303000402030201100400086E62742D +74726565030006020302012704000C626C6F636B2D656E74697479030008020302012804001463 +6F6D6D616E642D626C6F636B2D656E7469747903000A0203020129040011626C6F636B2D656E74 +6974792D7479706503000C020302010804000E746578742D636F6D706F6E656E7403000E020302 +012A04000A73636F7265626F617264030010020302012B0400087061727469636C650300120203 +02012C040005736F756E64030014020302012D04000E736F756E642D63617465676F7279030016 +020302012E04000B656E746974792D74797065030018020302012F04000562696F6D6503001A02 +0302010A04000961747472696275746503001C02030201300400126D6F6469666965722D6F7065 +726174696F6E03001E020302010B0400126174747269627574652D6D6F64696669657203002002 +0302011404000A6974656D2D737461636B030022020302013104000B64616D6167652D74797065 +030024020302013204000967616D652D72756C65030026020302013304000F67616D652D72756C +652D76616C756503002802030201340400047575696403002A016D08096D61696E2D68616E6408 +6F66662D68616E640466656574046C656773056368657374046865616404626F64790673616464 +6C6504000E65717569706D656E742D736C6F7403002C016D05066E6F726D616C0764657374726F +7905626C6F636B0669676E6F726509707573682D6F6E6C7904000F706973746F6E2D6265686176 +696F7203002E01710B047377696D00000D77616E6465722D61726F756E640176000C6D656C6565 +2D61747461636B0176000E6C6F6F6B2D61742D706C617965720176000B6C6F6F6B2D61726F756E +6400000D6573636170652D64616E6765720176000C61766F69642D656E746974790176000C626C +617A652D61747461636B00000E637265657065722D69676E6974650000096561742D6772617373 +00000D7A6F6D6269652D61747461636B01760004000F6275696C74696E2D61692D676F616C0300 +30016D1A07626C6F636B6564046F70656E0877616C6B61626C650D77616C6B61626C652D646F6F +720874726170646F6F720B706F776465722D736E6F771264616E6765722D706F776465722D736E +6F770566656E6365046C6176610577617465720C77617465722D626F72646572047261696C0F75 +6E7061737361626C652D7261696C0B64616E6765722D666972650B64616D6167652D666972650C +64616E6765722D6F746865720C64616D6167652D6F7468657209646F6F722D6F70656E10646F6F +722D776F6F642D636C6F73656410646F6F722D69726F6E2D636C6F73656406627265616368066C +65617665730C737469636B792D686F6E657905636F636F610F64616D6167652D63617574696F75 +730F64616E6765722D74726170646F6F7204000E706174682D6E6F64652D74797065030032016D +10057768697465066F72616E6765076D6167656E74610A6C696768742D626C75650679656C6C6F +77046C696D650470696E6B04677261790A6C696768742D67726179046379616E06707572706C65 +04626C75650562726F776E05677265656E0372656405626C61636B0400096479652D636F6C6F72 +030034016D0F046E6F6E650761726D6F72657207627574636865720C636172746F677261706865 +7206636C65726963066661726D6572096669736865726D616E08666C6574636865720D6C656174 +686572776F726B6572096C696272617269616E056D61736F6E066E697477697408736865706865 +726409746F6F6C736D6974680B776561706F6E736D69746804001376696C6C616765722D70726F +66657373696F6E03003601720205636F6C6F72350A69732D736865617265647F04000A73686565 +702D64617461030038016B2B0172060869732D74616D65647F056F776E65723A0A69732D736974 +74696E677F0C636F6C6C61722D636F6C6F72350869732D616E6772797F0A69732D62656767696E +677F040009776F6C662D6461746103003B0172040869732D74616D65647F056F776E65723A0A69 +732D73697474696E677F0C636F6C6C61722D636F6C6F72350400086361742D6461746103003D01 +72030A70726F66657373696F6E37056C6576656C7D0A657870657269656E63657904000D76696C +6C616765722D6461746103003F0172040A69732D706F77657265647F04667573657A0A69732D69 +676E697465647F106578706C6F73696F6E2D7261646975737D04000C637265657065722D646174 +610300410172010473697A657A04000A736C696D652D64617461030043016B7B01720313636172 +726965642D626C6F636B2D7374617465C5000C69732D73637265616D696E677F0A69732D737461 +72696E677F04000D656E6465726D616E2D646174610300460172011169732D706C617965722D63 +7265617465647F04000F69726F6E2D676F6C656D2D646174610300480172030A69732D73697474 +696E677F0B69732D736C656570696E677F0C69732D63726F756368696E677F040008666F782D64 +61746103004A0172030769732D626162797F036167657A0D696E2D6C6F76652D7469636B737A04 +000C61676561626C652D6461746103004C0172020769732D626162797F0F63616E2D627265616B +2D646F6F72737F04000B7A6F6D6269652D6461746103004E016D05046E6F6E6505626C6F636B03 +6D6F6203746E7407747269676765720400156578706C6F73696F6E2D696E746572616374696F6E +030050016E08106E6F746966792D6E65696768626F7273106E6F746966792D6C697374656E6572 +730B666F7263652D73746174650A736B69702D64726F7073056D6F76656424736B69702D726564 +73746F6E652D776972652D73746174652D7265706C6163656D656E7423736B69702D626C6F636B +2D656E746974792D7265706C616365642D63616C6C6261636B19736B69702D626C6F636B2D6164 +6465642D63616C6C6261636B04000B626C6F636B2D666C6167730300520172020D737072656164 +2D6368616E63657D0B6275726E2D6368616E63657D040009666C616D6D61626C65030054016D1B +046861727008626173656472756D05736E61726503686174046261737305666C7574650462656C +6C06677569746172056368696D650978796C6F70686F6E650E69726F6E2D78796C6F70686F6E65 +08636F772D62656C6C0A64696467657269646F6F036269740562616E6A6F05706C696E67077472 +756D7065740F7472756D7065742D6578706F736564107472756D7065742D6F786964697A656411 +7472756D7065742D776561746865726564067A6F6D62696508736B656C65746F6E076372656570 +657206647261676F6E0F7769746865722D736B656C65746F6E067069676C696E0B637573746F6D +2D686561640400146E6F7465626C6F636B2D696E737472756D656E7403005601707B016BD50001 +720F0269647B046E616D657308686172646E6573737610626C6173742D726573697374616E6365 +76096D61702D636F6C6F727D0C736C6970706572696E657373761376656C6F636974792D6D756C +7469706C69657276186A756D702D76656C6F636974792D6D756C7469706C69657276076974656D +2D69647B1064656661756C742D73746174652D69647B0973746174652D696473D8000869732D73 +6F6C69647F0669732D6169727F0C69732D666C616D6D61626C657F09666C616D6D61626C65D900 +040005626C6F636B03005A0172010269647B04000E626C6F636B2D73746174652D696403005C04 +0006656E74697479030104000D6C6976696E672D656E7469747903010400036D6F62030101695E +01720306656E74697479E100076869742D706F73010864697374616E6365750400177261792D74 +726163652D656E746974792D726573756C740300620400056368756E6B030104000C776F726C64 +2D626F726465720301017202036D696E01036D61780104000C626F756E64696E672D626F780300 +660170E700016F0273730170E90001721F0269647B08626C6F636B2D69647B0A626C6F636B2D6E +616D6573096C756D696E616E63657D076F7061636974797D08686172646E657373760669732D61 +69727F0969732D6C69717569647F0869732D736F6C69647F0C69732D66756C6C2D637562657F0F +706973746F6E2D6265686176696F722F106861732D72616E646F6D2D7469636B737F086275726E +61626C657F0D746F6F6C2D72657175697265647F1273696465642D7472616E73706172656E6379 +7F0B7265706C61636561626C657F0E69732D736F6C69642D626C6F636B7F11626C6F636B2D656E +746974792D747970657B0A696E737472756D656E74D70010636F6C6C6973696F6E2D7368617065 +73E8000E6F75746C696E652D736861706573E8000F646F776E2D736964652D736F6C69647F0D75 +702D736964652D736F6C69647F106E6F7274682D736964652D736F6C69647F10736F7574682D73 +6964652D736F6C69647F0F776573742D736964652D736F6C69647F0F656173742D736964652D73 +6F6C69647F11646F776E2D63656E7465722D736F6C69647F0F75702D63656E7465722D736F6C69 +647F096D61702D636F6C6F727D0A70726F70657274696573EA0004000B626C6F636B2D73746174 +6503006B01720303706F7305037961777605706974636876040014776F726C642D737061776E2D +6C6F636174696F6E03006D016D0604646F776E027570056E6F72746805736F7574680477657374 +046561737404000F626C6F636B2D646972656374696F6E03006F016B350172030D617474616368 +65642D66616365F0000B7065656B2D616D6F756E747D05636F6C6F72F10004000C7368756C6B65 +722D6461746103007201710D05736865657001390004776F6C66013C0003636174013E00087669 +6C6C6167657201C00000076372656570657201C2000005736C696D6501C4000008656E6465726D +616E01C700000A69726F6E2D676F6C656D01C9000003666F7801CB00000761676561626C6501CD +0000067A6F6D62696501CF0000077368756C6B657201F300000767656E6572696300000400086D +6F622D6461746103007401720203706F73050466616365F00004000E726179636173742D726573 +756C7403007601720303706F73050466616365F000076869742D706F73010400167261792D7472 +6163652D626C6F636B2D726573756C74030078040005776F726C640301016D040662696F6D6573 +056E6F697365077375726661636508666561747572657304001067656E65726174696F6E2D7068 +61736503007B04000C6368756E6B2D6275666665720301017202046E616D65730A70726F706572 +74696573EA00040010626C6F636B2D73746174652D696E666F03007E01685E0140010473656C66 +800100790400155B6D6574686F645D656E746974792E6765742D69640181010140010473656C66 +8001002B0400175B6D6574686F645D656E746974792E6765742D75756964018201014001047365 +6C66800100190400175B6D6574686F645D656E746974792E6765742D7479706501830101400104 +73656C668001000104001B5B6D6574686F645D656E746974792E6765742D706F736974696F6E01 +840101697A0140010473656C6680010085010400185B6D6574686F645D656E746974792E676574 +2D776F726C640186010140010473656C66800100760400165B6D6574686F645D656E746974792E +6765742D7961770187010400185B6D6574686F645D656E746974792E6765742D70697463680187 +0104001B5B6D6574686F645D656E746974792E6765742D686561642D7961770187010140030473 +656C66800103706F730109776F726C642D726566850101000400175B6D6574686F645D656E7469 +74792E74656C65706F72740188010140020473656C6680010876656C6F6369747901010004001B +5B6D6574686F645D656E746974792E7365742D76656C6F6369747901890104001B5B6D6574686F +645D656E746974792E6765742D76656C6F636974790184010140010473656C6680010003040017 +5B6D6574686F645D656E746974792E6765742D706F7365018A0101690F0140010473656C668001 +008B010400175B6D6574686F645D656E746974792E6765742D6E616D65018C010140020473656C +668001046E616D658B01010004001E5B6D6574686F645D656E746974792E7365742D637573746F +6D2D6E616D65018D01016B8B010140010473656C668001008E0104001E5B6D6574686F645D656E +746974792E6765742D637573746F6D2D6E616D65018F010140020473656C668001077669736962 +6C657F01000400265B6D6574686F645D656E746974792E7365742D637573746F6D2D6E616D652D +76697369626C650190010140010473656C668001007F0400255B6D6574686F645D656E74697479 +2E69732D637573746F6D2D6E616D652D76697369626C6501910104001E5B6D6574686F645D656E +746974792E69732D696E76756C6E657261626C650191010140020473656C6680010C696E76756C +6E657261626C657F010004001F5B6D6574686F645D656E746974792E7365742D696E76756C6E65 +7261626C650192010140010473656C668001007A04001D5B6D6574686F645D656E746974792E67 +65742D666972652D7469636B730193010140020473656C668001057469636B737A010004001D5B +6D6574686F645D656E746974792E7365742D666972652D7469636B730194010400205B6D657468 +6F645D656E746974792E6765742D66616C6C2D64697374616E63650187010140020473656C6680 +010864697374616E63657601000400205B6D6574686F645D656E746974792E7365742D66616C6C +2D64697374616E636501950104001E5B6D6574686F645D656E746974792E6765742D7469636B73 +2D6C6976656401930104001E5B6D6574686F645D656E746974792E7365742D7469636B732D6C69 +76656401940104001A5B6D6574686F645D656E746974792E69732D736E65616B696E6701910101 +40020473656C66800108736E65616B696E677F010004001B5B6D6574686F645D656E746974792E +7365742D736E65616B696E6701960104001B5B6D6574686F645D656E746974792E69732D737072 +696E74696E670191010140020473656C66800109737072696E74696E677F010004001C5B6D6574 +686F645D656E746974792E7365742D737072696E74696E6701970104001A5B6D6574686F645D65 +6E746974792E69732D7377696D6D696E670191010140020473656C668001087377696D6D696E67 +7F010004001B5B6D6574686F645D656E746974792E7365742D7377696D6D696E6701980104001B +5B6D6574686F645D656E746974792E69732D696E76697369626C650191010140020473656C6680 +0109696E76697369626C657F010004001C5B6D6574686F645D656E746974792E7365742D696E76 +697369626C650199010400195B6D6574686F645D656E746974792E69732D676C6F77696E670191 +010140020473656C66800107676C6F77696E677F010004001A5B6D6574686F645D656E74697479 +2E7365742D676C6F77696E67019A0104001D5B6D6574686F645D656E746974792E69732D66616C +6C2D666C79696E670191010140020473656C6680010B66616C6C2D666C79696E677F010004001E +5B6D6574686F645D656E746974792E7365742D66616C6C2D666C79696E67019B010400185B6D65 +74686F645D656E746974792E69732D73696C656E740191010140020473656C6680010673696C65 +6E747F01000400195B6D6574686F645D656E746974792E7365742D73696C656E74019C0104001A +5B6D6574686F645D656E746974792E6861732D677261766974790191010140020473656C668001 +07677261766974797F010004001E5B6D6574686F645D656E746974792E7365742D6861732D6772 +6176697479019D010400185B6D6574686F645D656E746974792E6765742D776964746801870104 +00195B6D6574686F645D656E746974792E6765742D6865696768740187010140030473656C6680 +01037961777605706974636876010004001B5B6D6574686F645D656E746974792E7365742D726F +746174696F6E019E0104001B5B6D6574686F645D656E746974792E69732D6F6E2D67726F756E64 +0191010400195B6D6574686F645D656E746974792E69732D6F6E2D666972650191010140020473 +656C668001076F6E2D666972657F010004001A5B6D6574686F645D656E746974792E7365742D6F +6E2D66697265019F0104001E5B6D6574686F645D656E746974792E6861732D76697375616C2D66 +6972650191010140020473656C6680010B76697375616C2D666972657F010004001E5B6D657468 +6F645D656E746974792E7365742D76697375616C2D6669726501A0010400225B6D6574686F645D +656E746974792E6765742D706F7274616C2D636F6F6C646F776E0181010140020473656C668001 +08636F6F6C646F776E7901000400225B6D6574686F645D656E746974792E7365742D706F727461 +6C2D636F6F6C646F776E01A1010400205B6D6574686F645D656E746974792E6765742D72656D61 +696E696E672D6169720193010140020473656C668001036169727A01000400205B6D6574686F64 +5D656E746974792E7365742D72656D61696E696E672D61697201A20104001A5B6D6574686F645D +656E746974792E6765742D6D61782D61697201930104001D5B6D6574686F645D656E746974792E +6765742D6579652D68656967687401870104001F5B6D6574686F645D656E746974792E6765742D +6579652D706F736974696F6E0184010170E1000140040473656C668001017875017975017A7500 +A3010400225B6D6574686F645D656E746974792E6765742D6E65617262792D656E746974696573 +01A401016BE1000140010473656C66800100A50104001A5B6D6574686F645D656E746974792E67 +65742D76656869636C6501A6010140020473656C6680010776656869636C65A501010004001A5B +6D6574686F645D656E746974792E7365742D76656869636C6501A7010140010473656C66800100 +A30104001D5B6D6574686F645D656E746974792E6765742D70617373656E6765727301A8010140 +020473656C6680010970617373656E676572E100010004001C5B6D6574686F645D656E74697479 +2E6164642D70617373656E67657201A90104001F5B6D6574686F645D656E746974792E72656D6F +76652D70617373656E67657201A9010140010473656C668001010004001F5B6D6574686F645D65 +6E746974792E656A6563742D70617373656E6765727301AA010140010473656C66800100E70004 +001F5B6D6574686F645D656E746974792E6765742D626F756E64696E672D626F7801AB0104001A +5B6D6574686F645D656E746974792E69732D696E2D77617465720191010400195B6D6574686F64 +5D656E746974792E69732D696E2D6C6176610191010400155B6D6574686F645D656E746974792E +72656D6F766501AA01016BF7000140030473656C6680010C6D61782D64697374616E6365750E66 +6C7569642D68616E646C696E677F00AC010400165B6D6574686F645D656E746974792E72617963 +61737401AD01016BF9000140030473656C6680010C6D61782D64697374616E6365750E696E636C +7564652D666C756964737F00AE0104001E5B6D6574686F645D656E746974792E7261792D747261 +63652D626C6F636B01AF01016BE3000140020473656C6680010C6D61782D64697374616E636575 +00B00104001F5B6D6574686F645D656E746974792E7261792D74726163652D656E7469747901B1 +010140020473656C6680010C6D61782D64697374616E63657500A5010400205B6D6574686F645D +656E746974792E6765742D7461726765742D656E7469747901B2010140040473656C668001096E +616D65737061636573036B6579730576616C756507010004001E5B6D6574686F645D656E746974 +792E7365742D637573746F6D2D6461746101B301016B070140030473656C668001096E616D6573 +7061636573036B65797300B40104001E5B6D6574686F645D656E746974792E6765742D63757374 +6F6D2D6461746101B5010140030473656C668001096E616D65737061636573036B657973010004 +00215B6D6574686F645D656E746974792E72656D6F76652D637573746F6D2D6461746101B60101 +40030473656C668001096E616D65737061636573036B657973007F04001E5B6D6574686F645D65 +6E746974792E6861732D637573746F6D2D6461746101B70101695F016BB8010140010473656C66 +800100B9010400185B6D6574686F645D656E746974792E61732D6C6976696E6701BA0101696001 +6BBB010140010473656C66800100BC010400155B6D6574686F645D656E746974792E61732D6D6F +6201BD010400185B6D6574686F645D656E746974792E69732D6C6976696E670191010400155B6D +6574686F645D656E746974792E69732D6D6F6201910101685F0140010473656C66BE0100E10004 +001F5B6D6574686F645D6C6976696E672D656E746974792E61732D656E7469747901BF01014001 +0473656C66BE0100BC0104001C5B6D6574686F645D6C6976696E672D656E746974792E61732D6D +6F6201C0010140010473656C66BE01007F04001C5B6D6574686F645D6C6976696E672D656E7469 +74792E69732D6D6F6201C1010140010473656C66BE0100760400205B6D6574686F645D6C697669 +6E672D656E746974792E6765742D6865616C746801C2010140020473656C66BE01066865616C74 +687601000400205B6D6574686F645D6C6976696E672D656E746974792E7365742D6865616C7468 +01C3010400245B6D6574686F645D6C6976696E672D656E746974792E6765742D6D61782D686561 +6C746801C2010140020473656C66BE010A6D61782D6865616C74687601000400245B6D6574686F +645D6C6976696E672D656E746974792E7365742D6D61782D6865616C746801C401014003047365 +6C66BE0106616D6F756E74760B64616D6167652D7479706525010004001C5B6D6574686F645D6C +6976696E672D656E746974792E64616D61676501C50104001D5B6D6574686F645D6C6976696E67 +2D656E746974792E69732D6465616401C1010400245B6D6574686F645D6C6976696E672D656E74 +6974792E6765742D6162736F727074696F6E01C2010140020473656C66BE0106616D6F756E7476 +01000400245B6D6574686F645D6C6976696E672D656E746974792E7365742D6162736F72707469 +6F6E01C6010140020473656C66BE0104617474721D00750400295B6D6574686F645D6C6976696E +672D656E746974792E6765742D6174747269627574652D76616C756501C7010400285B6D657468 +6F645D6C6976696E672D656E746974792E6765742D6174747269627574652D6261736501C70101 +40030473656C66BE0104617474721D0576616C75657501000400285B6D6574686F645D6C697669 +6E672D656E746974792E7365742D6174747269627574652D6261736501C8010140030473656C66 +BE0104617474721D086D6F64696669657221010004002C5B6D6574686F645D6C6976696E672D65 +6E746974792E6164642D6174747269627574652D6D6F64696669657201C9010140030473656C66 +BE0104617474721D02696473010004002F5B6D6574686F645D6C6976696E672D656E746974792E +72656D6F76652D6174747269627574652D6D6F64696669657201CA010170210140020473656C66 +BE0104617474721D00CB0104002D5B6D6574686F645D6C6976696E672D656E746974792E676574 +2D6174747269627574652D6D6F6469666965727301CC010140020473656C66BE0104617474721D +01000400255B6D6574686F645D6C6976696E672D656E746974792E72657365742D617474726962 +75746501CD010140010473656C66BE01010004002A5B6D6574686F645D6C6976696E672D656E74 +6974792E72657365742D616C6C2D6174747269627574657301CE01016923016BCF010140020473 +656C66BE0104736C6F742D00D0010400235B6D6574686F645D6C6976696E672D656E746974792E +6765742D65717569706D656E7401D1010140030473656C66BE0104736C6F742D05737461636BD0 +0101000400235B6D6574686F645D6C6976696E672D656E746974792E7365742D65717569706D65 +6E7401D2010400255B6D6574686F645D6C6976696E672D656E746974792E636C6561722D657175 +69706D656E7401CE010140010473656C66BE01007A04001D5B6D6574686F645D6C6976696E672D +656E746974792E6765742D61676501D3010140020473656C66BE01036167657A010004001D5B6D +6574686F645D6C6976696E672D656E746974792E7365742D61676501D4010140020473656C66BE +01076D6573736167658B0101000400295B6D6574686F645D6C6976696E672D656E746974792E73 +656E642D73797374656D2D6D65737361676501D5010168600140010473656C66D60100E1000400 +155B6D6574686F645D6D6F622E61732D656E7469747901D7010140010473656C66D60100B80104 +00155B6D6574686F645D6D6F622E61732D6C6976696E6701D8010140030473656C66D601087072 +696F726974797D04676F616C3101000400175B6D6574686F645D6D6F622E6164642D61692D676F +616C01D9010140030473656C66D601087072696F726974797D07676F616C2D696479010004001E +5B6D6574686F645D6D6F622E6164642D637573746F6D2D61692D676F616C01DA01014001047365 +6C66D601010004001A5B6D6574686F645D6D6F622E636C6561722D61692D676F616C7301DB0101 +40020473656C66D6010864697361626C65647F010004001B5B6D6574686F645D6D6F622E736574 +2D61692D64697361626C656401DC010140010473656C66D601007F04001A5B6D6574686F645D6D +6F622E69732D61692D64697361626C656401DD010140020473656C66D60106746172676574A501 +01000400165B6D6574686F645D6D6F622E7365742D74617267657401DE010140010473656C66D6 +0100A5010400165B6D6574686F645D6D6F622E6765742D74617267657401DF010140030473656C +66D60103706F730105737065656475007F04001B5B6D6574686F645D6D6F622E6E617669676174 +652D746F2D706F7301E0010140030473656C66D60106746172676574E10005737065656475007F +04001E5B6D6574686F645D6D6F622E6E617669676174652D746F2D656E7469747901E10104001B +5B6D6574686F645D6D6F622E73746F702D6E617669676174696F6E01DB010400195B6D6574686F +645D6D6F622E69732D6E617669676174696E6701DD010400235B6D6574686F645D6D6F622E6861 +732D726561636865642D64657374696E6174696F6E01DD010140020473656C66D6010573706565 +647501000400205B6D6574686F645D6D6F622E7365742D6E617669676174696F6E2D7370656564 +01E2010140030473656C66D60103706F73010C6D61782D64697374616E636576007F0400155B6D +6574686F645D6D6F622E63616E2D726561636801E3010140030473656C66D601096E6F64652D74 +79706533056D616C75737601000400215B6D6574686F645D6D6F622E7365742D7061746866696E +64696E672D6D616C757301E4010140020473656C66D601096E6F64652D74797065330076040021 +5B6D6574686F645D6D6F622E6765742D7061746866696E64696E672D6D616C757301E501014002 +0473656C66D60103706F730101000400135B6D6574686F645D6D6F622E6C6F6F6B2D617401E601 +0140020473656C66D60106746172676574E100010004001A5B6D6574686F645D6D6F622E6C6F6F +6B2D61742D656E7469747901E7010140010473656C66D60100F5000400185B6D6574686F645D6D +6F622E6765742D6D6F622D6461746101E8010140020473656C66D6010464617461F500007F0400 +185B6D6574686F645D6D6F622E7365742D6D6F622D6461746101E9010140020473656C66D60105 +7469636B737A010004001C5B6D6574686F645D6D6F622E7365742D667265657A652D7469636B73 +01EA010140010473656C66D601007A04001C5B6D6574686F645D6D6F622E6765742D667265657A +652D7469636B7301EB010168640140010473656C66EC01007A0400135B6D6574686F645D636875 +6E6B2E6765742D7801ED010400135B6D6574686F645D6368756E6B2E6765742D7A01ED01014002 +0473656C66EC0103706F7305007B0400205B6D6574686F645D6368756E6B2E6765742D626C6F63 +6B2D73746174652D696401EE010140020473656C66EC0103706F730500EC0004001D5B6D657468 +6F645D6368756E6B2E6765742D626C6F636B2D737461746501EF010140030473656C66EC010370 +6F73050573746174657B010004001D5B6D6574686F645D6368756E6B2E7365742D626C6F636B2D +737461746501F0010140020473656C66EC0103706F730500DB000400175B6D6574686F645D6368 +756E6B2E6765742D626C6F636B01F1010140030473656C66EC0103706F730505626C6F636BDB00 +01000400175B6D6574686F645D6368756E6B2E7365742D626C6F636B01F2010140030473656C66 +EC0103706F730508626C6F636B2D69647B010004001D5B6D6574686F645D6368756E6B2E736574 +2D626C6F636B2D62792D696401F3010140020473656C66EC0103706F7305001B0400175B6D6574 +686F645D6368756E6B2E6765742D62696F6D6501F401016B0D0140020473656C66EC0103706F73 +0500F50104001E5B6D6574686F645D6368756E6B2E6765742D626C6F636B2D656E7469747901F6 +010140030473656C66EC0101787A017A7A007A04001D5B6D6574686F645D6368756E6B2E676574 +2D746F702D626C6F636B2D7901F7010140020473656C66EC0103706F7305007D04001B5B6D6574 +686F645D6368756E6B2E6765742D736B792D6C6967687401F80104001D5B6D6574686F645D6368 +756E6B2E6765742D626C6F636B2D6C6967687401F8010140040473656C66EC01096E616D657370 +61636573036B6579730576616C756507010004001D5B6D6574686F645D6368756E6B2E7365742D +637573746F6D2D6461746101F9010140030473656C66EC01096E616D65737061636573036B6579 +7300B40104001D5B6D6574686F645D6368756E6B2E6765742D637573746F6D2D6461746101FA01 +0140030473656C66EC01096E616D65737061636573036B65797301000400205B6D6574686F645D +6368756E6B2E72656D6F76652D637573746F6D2D6461746101FB010140030473656C66EC01096E +616D65737061636573036B657973007F04001D5B6D6574686F645D6368756E6B2E6861732D6375 +73746F6D2D6461746101FC010168650140010473656C66FD0100750400215B6D6574686F645D77 +6F726C642D626F726465722E6765742D63656E7465722D7801FE010400215B6D6574686F645D77 +6F726C642D626F726465722E6765742D63656E7465722D7A01FE010140010473656C66FD010001 +04001F5B6D6574686F645D776F726C642D626F726465722E6765742D63656E74657201FF010140 +030473656C66FD01017875017A75010004001F5B6D6574686F645D776F726C642D626F72646572 +2E7365742D63656E7465720180020400215B6D6574686F645D776F726C642D626F726465722E67 +65742D6469616D6574657201FE0104001D5B6D6574686F645D776F726C642D626F726465722E67 +65742D73697A6501FE01016B770140030473656C66FD01086469616D6574657275057370656564 +810201000400215B6D6574686F645D776F726C642D626F726465722E7365742D6469616D657465 +720182020140020473656C66FD010473697A6575010004001D5B6D6574686F645D776F726C642D +626F726465722E7365742D73697A650183020140030473656C66FD01086E65772D73697A65750C +74696D652D7365636F6E64737701000400285B6D6574686F645D776F726C642D626F726465722E +7365742D73697A652D7472616E736974696F6E0184020400285B6D6574686F645D776F726C642D +626F726465722E6765742D7461726765742D6469616D6574657201FE010140010473656C66FD01 +00780400255B6D6574686F645D776F726C642D626F726465722E6765742D7461726765742D7370 +6565640185020140010473656C66FD01007A0400295B6D6574686F645D776F726C642D626F7264 +65722E6765742D7761726E696E672D64697374616E63650186020140020473656C66FD01086469 +7374616E63657A01000400295B6D6574686F645D776F726C642D626F726465722E7365742D7761 +726E696E672D64697374616E63650187020400265B6D6574686F645D776F726C642D626F726465 +722E6765742D7761726E696E672D64656C61790186020140020473656C66FD010564656C61797A +01000400265B6D6574686F645D776F726C642D626F726465722E7365742D7761726E696E672D64 +656C61790188020400255B6D6574686F645D776F726C642D626F726465722E6765742D7761726E +696E672D74696D650186020140020473656C66FD010474696D657A01000400255B6D6574686F64 +5D776F726C642D626F726465722E7365742D7761726E696E672D74696D650189020400265B6D65 +74686F645D776F726C642D626F726465722E6765742D64616D6167652D62756666657201FE0101 +40020473656C66FD01066275666665727501000400265B6D6574686F645D776F726C642D626F72 +6465722E7365742D64616D6167652D627566666572018A020400265B6D6574686F645D776F726C +642D626F726465722E6765742D64616D6167652D616D6F756E7401FE010140020473656C66FD01 +0664616D6167657501000400265B6D6574686F645D776F726C642D626F726465722E7365742D64 +616D6167652D616D6F756E74018B020140030473656C66FD01017875017A75007F04001D5B6D65 +74686F645D776F726C642D626F726465722E636F6E7461696E73018C020140020473656C66FD01 +03706F7301007F0400215B6D6574686F645D776F726C642D626F726465722E636F6E7461696E73 +2D706F73018D020140010473656C66FD01010004001A5B6D6574686F645D776F726C642D626F72 +6465722E7265736574018E0201687A0140010473656C668F0200730400145B6D6574686F645D77 +6F726C642E6765742D69640190020169650140010473656C668F020091020400185B6D6574686F +645D776F726C642E6765742D626F7264657201920204001E5B6D6574686F645D776F726C642E67 +65742D776F726C642D626F72646572019202016964016B93020140030473656C668F0201787A01 +7A7A0094020400175B6D6574686F645D776F726C642E6765742D6368756E6B0195020140020473 +656C668F0203706F7305007B0400205B6D6574686F645D776F726C642E6765742D626C6F636B2D +73746174652D69640196020140020473656C668F0203706F730500EC0004001D5B6D6574686F64 +5D776F726C642E6765742D626C6F636B2D73746174650197020140040473656C668F0203706F73 +050573746174657B0C7570646174652D666C616773D300010004001D5B6D6574686F645D776F72 +6C642E7365742D626C6F636B2D73746174650198020140020473656C668F0203706F730500DB00 +0400175B6D6574686F645D776F726C642E6765742D626C6F636B01990204001A5B6D6574686F64 +5D776F726C642E6765742D626C6F636B2D69640196020140040473656C668F0203706F73050562 +6C6F636BDB000C7570646174652D666C616773D30001000400175B6D6574686F645D776F726C64 +2E7365742D626C6F636B019A020140040473656C668F0203706F730508626C6F636B2D69647B0C +7570646174652D666C616773D300010004001D5B6D6574686F645D776F726C642E7365742D626C +6F636B2D62792D6964019B020140040473656C668F0203706F7305046E616D65730C7570646174 +652D666C616773D300007F04001F5B6D6574686F645D776F726C642E7365742D626C6F636B2D62 +792D6E616D65019C020140010473656C668F02007704001D5B6D6574686F645D776F726C642E67 +65742D74696D652D6F662D646179019D020140020473656C668F020474696D6577010004001D5B +6D6574686F645D776F726C642E7365742D74696D652D6F662D646179019E0204001B5B6D657468 +6F645D776F726C642E6765742D776F726C642D616765019D0204001B5B6D6574686F645D776F72 +6C642E6765742D64696D656E73696F6E0190020140010473656C668F0200EE000400205B6D6574 +686F645D776F726C642E6765742D737061776E2D6C6F636174696F6E019F020140030473656C66 +8F0201787A017A7A007A04001D5B6D6574686F645D776F726C642E6765742D746F702D626C6F63 +6B2D7901A0020400285B6D6574686F645D776F726C642E6765742D6D6F74696F6E2D626C6F636B +696E672D68656967687401A0020140010473656C668F02007F0400185B6D6574686F645D776F72 +6C642E69732D7261696E696E6701A1020140020473656C668F02077261696E696E677F01000400 +195B6D6574686F645D776F726C642E7365742D7261696E696E6701A20204001B5B6D6574686F64 +5D776F726C642E69732D7468756E646572696E6701A1020140020473656C668F020A7468756E64 +6572696E677F010004001C5B6D6574686F645D776F726C642E7365742D7468756E646572696E67 +01A3020140030473656C668F02076D6573736167658B01076F7665726C61797F01000400265B6D +6574686F645D776F726C642E62726F6164636173742D73797374656D2D6D65737361676501A402 +0169110140010473656C668F0200A50204001C5B6D6574686F645D776F726C642E6765742D7363 +6F7265626F61726401A6020140060473656C668F0205736F756E64150863617465676F72791703 +706F730106766F6C756D65760570697463687601000400185B6D6574686F645D776F726C642E70 +6C61792D736F756E6401A7020140060473656C668F020A736F756E642D6E616D65730863617465 +676F72791703706F730106766F6C756D657605706974636876010004001F5B6D6574686F645D77 +6F726C642E706C61792D637573746F6D2D736F756E6401A8020140060473656C668F0208706172 +7469636C651303706F7301066F666673657401096D61782D73706565647605636F756E747A0100 +04001C5B6D6574686F645D776F726C642E737061776E2D7061727469636C6501A9020140050473 +656C668F0203706F730105706F776572760B6372656174652D666972657F0B696E746572616374 +696F6ED100010004001E5B6D6574686F645D776F726C642E6372656174652D6578706C6F73696F +6E01AA020140010473656C668F02007A04001B5B6D6574686F645D776F726C642E6765742D7365 +612D6C6576656C01AB020400175B6D6574686F645D776F726C642E6765742D6D696E2D7901AB02 +0140020473656C668F0203706F7305007D04001B5B6D6574686F645D776F726C642E6765742D73 +6B792D6C6967687401AC020140030473656C668F0203706F7305056C6576656C7D010004001B5B +6D6574686F645D776F726C642E7365742D736B792D6C6967687401AD0204001D5B6D6574686F64 +5D776F726C642E6765742D626C6F636B2D6C6967687401AC0204001D5B6D6574686F645D776F72 +6C642E7365742D626C6F636B2D6C6967687401AD020140020473656C668F0203706F7305001B04 +00175B6D6574686F645D776F726C642E6765742D62696F6D6501AE020140030473656C668F020B +656E746974792D747970651903706F730100E10004001A5B6D6574686F645D776F726C642E7370 +61776E2D656E7469747901AF020140010473656C668F0200A30104001A5B6D6574686F645D776F +726C642E6765742D656E74697469657301B0020140030473656C668F0203706F73010B65666665 +63742D6F6E6C797F010004001E5B6D6574686F645D776F726C642E737472696B652D6C69676874 +6E696E6701B102016B010140030473656C668F020573746172740103656E640100B20204001E5B +6D6574686F645D776F726C642E7261792D74726163652D626C6F636B7301B3020140040473656C +668F020573746172740103656E64010E696E636C7564652D666C756964737F00AE0104001D5B6D +6574686F645D776F726C642E7261792D74726163652D626C6F636B01B4020140030473656C668F +020573746172740103656E640100B00104001E5B6D6574686F645D776F726C642E7261792D7472 +6163652D656E7469747901B5020170E3000140030473656C668F020573746172740103656E6401 +00B6020400205B6D6574686F645D776F726C642E7261792D74726163652D656E74697469657301 +B7020140020473656C668F0203706F730500F50104001E5B6D6574686F645D776F726C642E6765 +742D626C6F636B2D656E7469747901B80201707D016BB9020140020473656C668F0203706F7305 +00BA020400225B6D6574686F645D776F726C642E6765742D626C6F636B2D656E746974792D6E62 +7401BB02016A0001730140030473656C668F0203706F7305086E62742D64617461B90200BC0204 +00225B6D6574686F645D776F726C642E7365742D626C6F636B2D656E746974792D6E627401BD02 +0400165B6D6574686F645D776F726C642E6765742D6E616D650190020140010473656C668F0200 +BC020400125B6D6574686F645D776F726C642E7361766501BE020140020473656C668F020C6765 +6E657261746F722D69647901000400215B6D6574686F645D776F726C642E7365742D6368756E6B +2D67656E657261746F7201BF020140040473656C668F02096E616D65737061636573036B657973 +0576616C756507010004001D5B6D6574686F645D776F726C642E7365742D637573746F6D2D6461 +746101C0020140030473656C668F02096E616D65737061636573036B65797300B40104001D5B6D +6574686F645D776F726C642E6765742D637573746F6D2D6461746101C1020140030473656C668F +02096E616D65737061636573036B65797301000400205B6D6574686F645D776F726C642E72656D +6F76652D637573746F6D2D6461746101C2020140030473656C668F02096E616D65737061636573 +036B657973007F04001D5B6D6574686F645D776F726C642E6861732D637573746F6D2D64617461 +01C3020140020473656C668F020472756C6527002904001B5B6D6574686F645D776F726C642E67 +65742D67616D652D72756C6501C4020140030473656C668F020472756C65270576616C75652901 +0004001B5B6D6574686F645D776F726C642E7365742D67616D652D72756C6501C50201687D0140 +010473656C66C602007A04001A5B6D6574686F645D6368756E6B2D6275666665722E6765742D78 +01C70204001A5B6D6574686F645D6368756E6B2D6275666665722E6765742D7A01C70204001E5B +6D6574686F645D6368756E6B2D6275666665722E6765742D6D696E2D7901C7020140010473656C +66C602007904001F5B6D6574686F645D6368756E6B2D6275666665722E6765742D686569676874 +01C8020140050473656C66C60201787D01797A017A7D0873746174652D69647B01000400275B6D +6574686F645D6368756E6B2D6275666665722E7365742D626C6F636B2D73746174652D696401C9 +020140040473656C66C60201787D01797A017A7D007B0400275B6D6574686F645D6368756E6B2D +6275666665722E6765742D626C6F636B2D73746174652D696401CA020140030473656C66C60201 +797A0873746174652D69647B010004001F5B6D6574686F645D6368756E6B2D6275666665722E66 +696C6C2D6C6179657201CB020140060473656C66C60201787D056D696E2D797A056D61782D797A +017A7D0873746174652D69647B010004001F5B6D6574686F645D6368756E6B2D6275666665722E +66696C6C2D72616E676501CC020140080473656C66C602056D696E2D787D056D696E2D797A056D +696E2D7A7D056D61782D787D056D61782D797A056D61782D7A7D0873746174652D69647B010004 +00205B6D6574686F645D6368756E6B2D6275666665722E66696C6C2D6375626F696401CD020140 +050473656C66C60201787D01797A017A7D0562696F6D651B010004001E5B6D6574686F645D6368 +756E6B2D6275666665722E7365742D62696F6D6501CE020140020473656C66C6020562696F6D65 +1B010004001F5B6D6574686F645D6368756E6B2D6275666665722E66696C6C2D62696F6D6501CF +02014002046E616D65730A70726F70657274696573EA0000C5000400137265736F6C76652D626C +6F636B2D737461746501D002016BFF000140010873746174652D69647B00D102040013626C6F63 +6B2D73746174652D746F2D696E666F01D202016BDB000140010269647B00D30204000F6765742D +626C6F636B2D62792D696401D402014001046E616D657300D3020400116765742D626C6F636B2D +62792D6E616D6501D5020170DB0001400000D60204000E6765742D616C6C2D626C6F636B7301D7 +0201707301400000D8020400136765742D616C6C2D626C6F636B2D6E616D657301D90201400000 +7904000F6765742D626C6F636B2D636F756E7401DA020400156765742D626C6F636B2D73746174 +652D636F756E7401DA020170EC0001400105626C6F636BDB0000DB020400146765742D73746174 +65732D666F722D626C6F636B01DC0201400108626C6F636B2D69647B00DB020400176765742D73 +74617465732D666F722D626C6F636B2D696401DD0201400108626C6F636B2D69647B00D8000400 +1A6765742D73746174652D6964732D666F722D626C6F636B2D696401DE02014001087374617465 +2D69647B00EA000400146765742D626C6F636B2D70726F7065727469657301DF02014001087374 +6174652D69647B00D3020400176765742D626C6F636B2D66726F6D2D73746174652D696401E002 +014001057374617465EC0000DB000400146765742D626C6F636B2D66726F6D2D737461746501E1 +0201400105626C6F636BDB0000EC0004001C6765742D64656661756C742D73746174652D66726F +6D2D626C6F636B01E202016BEC0001400108626C6F636B2D69647B00E30204001F6765742D6465 +6661756C742D73746174652D66726F6D2D626C6F636B2D696401E4020140010873746174652D69 +647B00E3020400156765742D626C6F636B2D73746174652D62792D696401E50203001A70756D70 +6B696E3A706C7567696E2F776F726C6440302E312E300535014209016D05047A65726F036F6E65 +0374776F05746872656504666F75720400107065726D697373696F6E2D6C6576656C0300000171 +030464656E79000005616C6C6F770000026F700101000400127065726D697373696F6E2D646566 +61756C74030002017202046E6F6465730576616C75657F0400107065726D697373696F6E2D6368 +696C64030004017005017204046E6F6465730B6465736372697074696F6E730764656661756C74 +03086368696C6472656E0604000A7065726D697373696F6E03000703001F70756D706B696E3A70 +6C7567696E2F7065726D697373696F6E40302E312E30053601421B020302010804000E74657874 +2D636F6D706F6E656E74030000016D020375726C047061746804000A696D6167652D7479706503 +000201720204747970650304646174617304000A666F726D2D696D616765030004016901016B05 +01720204746578740605696D6167650704001273696D706C652D666F726D2D627574746F6E0300 +08017009017203057469746C650607636F6E74656E740607627574746F6E730A04000B73696D70 +6C652D666F726D03000B017204057469746C650607636F6E74656E740607627574746F6E310607 +627574746F6E320604000A6D6F64616C2D666F726D03000D016F02067F016F0506767676760170 +73016F03061179016F03067373017106056C6162656C01060006746F67676C65010F0006736C69 +6465720110000B737465702D736C696465720112000864726F70646F776E01120005696E707574 +011300040013637573746F6D2D666F726D2D656C656D656E74030014017015017202057469746C +650608656C656D656E74731604000B637573746F6D2D666F726D0300170171030673696D706C65 +010C00056D6F64616C010E0006637573746F6D011800040004666F726D03001903001A70756D70 +6B696E3A706C7567696E2F666F726D7340302E312E30053701422F020302010804000E74657874 +2D636F6D706F6E656E74030000020302011404000A6974656D2D737461636B030002016D05066E +6F746963650C636F6E6669726D6174696F6E0C6D756C74692D616374696F6E0B6469616C6F672D +6C6973740C7365727665722D6C696E6B7304000B6469616C6F672D747970650300040169010169 +030171020D706C61696E2D6D657373616765010600046974656D01070004000B6469616C6F672D +626F6479030008017202056C6162656C060D64656661756C742D76616C75657F0400116469616C +6F672D696E7075742D626F6F6C03000A017203056C6162656C060B706C616365686F6C64657206 +0D64656661756C742D76616C7565730400116469616C6F672D696E7075742D7465787403000C01 +6B73017206056C6162656C06096D696E2D76616C756576096D61782D76616C7565760D696E6974 +69616C2D76616C7565760473746570760C6C6162656C2D666F726D61740E0400196469616C6F67 +2D696E7075742D6E756D6265722D72616E676503000F017006017203056C6162656C06076F7074 +696F6E73110D696E697469616C2D696E6465787904001A6469616C6F672D696E7075742D73696E +676C652D6F7074696F6E03001201710404626F6F6C010B000474657874010D000C6E756D626572 +2D72616E67650110000D73696E676C652D6F7074696F6E01130004000C6469616C6F672D696E70 +7574030014016D02047065656B03706F7004000C61667465722D616374696F6E03001601707D01 +6B1801720202696473077061796C6F616419040013637573746F6D2D636C69636B2D616374696F +6E03001A017102086F70656E2D75726C0173000C637573746F6D2D636C69636B011B0004000661 +6374696F6E03001C016B06016B7901720404746578740607746F6F6C7469701E0577696474681F +06616374696F6E1D04000D616374696F6E2D627574746F6E030020016D0A0A6275672D7265706F +727414636F6D6D756E6974792D67756964656C696E657307737570706F72740673746174757308 +666565646261636B09636F6D6D756E697479077765627369746506666F72756D73046E6577730D +616E6E6F756E63656D656E74730400096C696E6B2D74797065030022017102086275696C742D69 +6E01230006637573746F6D01060004000A6C696E6B2D6C6162656C030024017202056C6162656C +250375726C730400046C696E6B030026017009017015017021017027016B17017209057469746C +650604747970650504626F64792806696E707574732907627574746F6E732A056C696E6B732B0C +61667465722D616374696F6E2C1563616E2D636C6F73652D776974682D6573636170657F0E6578 +7465726E616C2D7469746C651E0400066469616C6F6703002D03002170756D706B696E3A706C75 +67696E2F6A6176612D6469616C6F677340302E312E30053801429B050203020134040004757569 +64030000017208066C6F63616C65730D766965772D64697374616E63657D09636861742D6D6F64 +657A0B636861742D636F6C6F72737F0A736B696E2D70617274737D096D61696E2D68616E647A0E +746578742D66696C746572696E677F0E7365727665722D6C697374696E677F040022636F6E6669 +672D732D636C69656E742D696E666F726D6174696F6E2D636F6E66696703000201707D016B0401 +7203036B6579730B6861732D7061796C6F61647F077061796C6F61640504001F636F6E6669672D +732D636F6E6669672D636F6F6B69652D726573706F6E736503000601720209616374696F6E2D69 +6473077061796C6F61640504001C636F6E6669672D732D637573746F6D2D636C69636B2D616374 +696F6E0300080172010D6B6565702D616C6976652D696478040013636F6E6669672D732D6B6565 +702D616C69766503000A0170730172010B6B6E6F776E2D7061636B730C040014636F6E6669672D +732D6B6E6F776E2D7061636B7303000D017202076368616E6E656C73046461746104040017636F +6E6669672D732D706C7567696E2D6D65737361676503000F0172010269647A040014636F6E6669 +672D732D636F6E6669672D706F6E6703001101710910646F776E6C6F61642D7375636365737300 +000D646F776E6C6F61642D6661696C00000A646F776E6C6F616465640000086163636570746564 +0000086465636C696E656400000B696E76616C69642D75726C00000D72656C6F61642D6661696C +6564000009646973636172646564000007756E6B6E6F776E017A0004001D7265736F757263652D +7061636B2D726573706F6E73652D726573756C7403001301720204757569640106726573756C74 +7A04001D636F6E6669672D732D636F6E6669672D7265736F757263652D7061636B030015017202 +036B657973077061796C6F61640504001D6C6F67696E2D732D6C6F67696E2D636F6F6B69652D72 +6573706F6E73650300170172020D7368617265642D736563726574040C7665726966792D746F6B +656E04040015732D656E6372797074696F6E2D726573706F6E7365030019017202046E616D6573 +0475756964010400136C6F67696E2D732D6C6F67696E2D737461727403001B0172020A6D657373 +6167652D69647A04646174610504001D6C6F67696E2D732D6C6F67696E2D706C7567696E2D7265 +73706F6E736503001D01720109656E746974792D69647A040008732D61747461636B03001F016F +037A7A7A0172020E7472616E73616374696F6E2D69647A086C6F636174696F6E21040018732D62 +6C6F636B2D656E746974792D7461672D717565727903002201720207736C6F742D69647A137365 +6C65637465642D6974656D2D696E6465787A040016732D62756E646C652D6974656D2D73656C65 +637465640300240172010A646966666963756C747973040013732D6368616E67652D6469666669 +63756C74790300260172010967616D652D6D6F646573040012732D6368616E67652D67616D652D +6D6F6465030028017201066F66667365747A04000A732D636861742D61636B03002A0172010763 +6F6D6D616E647304000E732D636861742D636F6D6D616E6403002C017202046E616D6573097369 +676E617475726504040012617267756D656E742D7369676E617475726503002E01702F01720707 +636F6D6D616E64730974696D657374616D70780473616C747813617267756D656E742D7369676E +617475726573300D6D6573736167652D636F756E747A0C61636B6E6F776C656467656404086368 +65636B73756D7D040015732D636861742D636F6D6D616E642D7369676E6564030031017207076D +657373616765730974696D657374616D70780473616C7478097369676E6174757265050D6D6573 +736167652D636F756E747A0C61636B6E6F776C65646765640408636865636B73756D7D04000E73 +2D636861742D6D6573736167650300330172010F6368756E6B732D7065722D7469636B7604000D +732D6368756E6B2D6261746368030035016D07067069636B75700A717569636B2D6D6F76650473 +77617005636C6F6E65057468726F770B717569636B2D63726166740A7069636B75702D616C6C04 +0010736C6F742D616374696F6E2D74797065030037016F027A730170390172080773796E632D69 +647A087265766973696F6E7A04736C6F747A06627574746F6E7D046D6F6465380F6C656E677468 +2D6F662D61727261797A1661727261792D6F662D6368616E6765642D736C6F74733A0C63617272 +6965642D6974656D7304000C732D636C69636B2D736C6F7403003B01720109616374696F6E2D69 +647A040010732D636C69656E742D636F6D6D616E6403003D017208066C6F63616C65730D766965 +772D64697374616E63657D09636861742D6D6F64657A0B636861742D636F6C6F72737F0A736B69 +6E2D70617274737D096D61696E2D68616E647A0E746578742D66696C746572696E677F0E736572 +7665722D6C697374696E677F040019732D636C69656E742D696E666F726D6174696F6E2D706C61 +7903003F0172010977696E646F772D69647A040011732D636C6F73652D636F6E7461696E657203 +00410172020269647A07636F6D6D616E6473040014732D636F6D6D616E642D7375676765737469 +6F6E0300430172010B74656C65706F72742D69647A040012732D636F6E6669726D2D74656C6570 +6F72740300450172020977696E646F772D69647A09627574746F6E2D69647A040018732D636F6E +7461696E65722D627574746F6E2D636C69636B03004701720307736C6F742D69647A0C636F6E74 +61696E65722D69647A096E65772D73746174657F04001E732D636F6E7461696E65722D736C6F74 +2D73746174652D6368616E676564030049017202036B657973077061796C6F616405040011732D +636F6F6B69652D726573706F6E736503004B01720209616374696F6E2D696473077061796C6F61 +6405040015732D637573746F6D2D636C69636B2D616374696F6E03004D017202076368616E6E65 +6C73046461746104040010732D637573746F6D2D7061796C6F616403004F0172010B73616D706C +652D747970657A04001B732D64656275672D73616D706C652D737562736372697074696F6E0300 +510172010B73616D706C652D747970657A04001C732D64656275672D737562736372697074696F +6E2D72657175657374030053016B7301720304736C6F747A0570616765730C057469746C65D500 +04000B732D656469742D626F6F6B0300560172020E7472616E73616374696F6E2D69647A09656E +746974792D69647A040012732D656E746974792D7461672D7175657279030058016F0375757501 +6BDA00016B7A01720509656E746974792D69647A06722D747970657A0F7461726765742D706F73 +6974696F6EDB000468616E64DC0008736E65616B696E677F04000A732D696E7465726163740300 +5D016D0308696E7465726163740661747461636B0B696E7465726163742D617404000B61637469 +6F6E2D7479706503005F01720303706F7321066C6576656C737A0C6B6565702D6A696773617773 +7F040011732D6A69677361772D67656E65726174650300610172010D6B6565702D616C6976652D +69647804000C732D6B6565702D616C697665030063017201066C6F636B65647F040011732D6C6F +636B2D646966666963756C7479030065017206017875017975017A750379617776057069746368 +76096F6E2D67726F756E647F04000E732D6D6F76652D76656869636C650300670172020B6C6566 +742D706164646C657F0C72696768742D706164646C657F04000D732D706164646C652D626F6174 +03006901720203706F73210C696E636C7564652D646174617F040016732D7069636B2D6974656D +2D66726F6D2D626C6F636B03006B0172020269647A0C696E636C7564652D646174617F04001773 +2D7069636B2D6974656D2D66726F6D2D656E7469747903006D017201077061796C6F6164780400 +13732D706C61792D70696E672D7265717565737403006F0172030C636F6E7461696E65722D6964 +7D117265636970652D646973706C61792D69647A0D7573652D6D61782D6974656D737F04000E73 +2D706C6163652D726563697065030071016B7601720305666C6167737D09666C792D7370656564 +F3000A77616C6B2D7370656564F300040012732D706C617965722D6162696C6974696573030074 +017204067374617475737A08706F736974696F6E2104666163657D0873657175656E63657A0400 +0F732D706C617965722D616374696F6E030076016D080F737461727465642D64696767696E6711 +63616E63656C6C65642D64696767696E671066696E69736865642D64696767696E670F64726F70 +2D6974656D2D737461636B0964726F702D6974656D1372656C656173652D6974656D2D696E2D75 +736509737761702D6974656D0973706561722D6A6162040006737461747573030078016D090E73 +746172742D736E65616B696E670D73746F702D736E65616B696E67096C656176652D6265640F73 +746172742D737072696E74696E670E73746F702D737072696E74696E671073746172742D686F72 +73652D6A756D700F73746F702D686F7273652D6A756D70166F70656E2D76656869636C652D696E +76656E746F72791373746172742D666C79696E672D656C79747261040006616374696F6E03007A +01720309656E746974792D69647A06616374696F6EFB000A6A756D702D626F6F73747A04001073 +2D706C617965722D636F6D6D616E6403007C017201096F6E2D67726F756E647F040013732D7365 +742D706C617965722D67726F756E6403007E01720105696E7075747D04000E732D706C61796572 +2D696E7075740300800101720208706F736974696F6EDA0009636F6C6C6973696F6E7D04001173 +2D706C617965722D706F736974696F6E0300820101720408706F736974696F6EDA000379617776 +0570697463687609636F6C6C6973696F6E7D04001A732D706C617965722D706F736974696F6E2D +726F746174696F6E030084010172030379617776057069746368760667726F756E647F04001173 +2D706C617965722D726F746174696F6E030086010172040A73657373696F6E2D6964010A657870 +697265732D6174780A7075626C69632D6B6579040D6B65792D7369676E61747572650404001073 +2D706C617965722D73657373696F6E030088010172010269647A04000B732D706C61792D706F6E +6703008A0101720309626F6F6B2D747970657A0769732D6F70656E7F0C69732D66696C74657269 +6E677F04001D732D7265636970652D626F6F6B2D6368616E67652D73657474696E677303008C01 +017201117265636970652D646973706C61792D69647A040019732D7265636970652D626F6F6B2D +7365656E2D72656369706503008E01017201096974656D2D6E616D657304000D732D72656E616D +652D6974656D0300900101710910646F776E6C6F61642D737563636573730000086465636C696E +656400000D646F776E6C6F61642D6661696C000008616363657074656400000A646F776E6C6F61 +64656400000B696E76616C69642D75726C00000D72656C6F61642D6661696C6564000009646973 +636172646564000007756E6B6E6F776E017A00040019706C61792D7265736F757263652D706163 +6B2D726573756C740300920101720204757569640106726573756C747A040014732D706C61792D +7265736F757263652D7061636B03009401017102086F70656E2D74616201730009636C6F73652D +7461620000040012732D7365656E2D616476616E63656D656E74030096010172010D73656C6563 +7465642D736C6F747A04000E732D73656C6563742D7472616465030098010172020E7072696D61 +72792D656666656374DC00107365636F6E646172792D656666656374DC0004000C732D7365742D +626561636F6E03009A0101720403706F732107636F6D6D616E6473046D6F64657A05666C616773 +7D040013732D7365742D636F6D6D616E642D626C6F636B03009C01016D0305636861696E097265 +70656174696E6707696D70756C7365040012636F6D6D616E642D626C6F636B2D6D6F646503009E +0101720309656E746974792D69647A07636F6D6D616E64730C747261636B2D6F75747075747F04 +0016732D7365742D636F6D6D616E642D6D696E65636172740300A00101720204736C6F747A0C63 +6C69636B65642D6974656D73040013732D7365742D63726561746976652D736C6F740300A20101 +72020D67616D652D72756C652D6B6579730576616C75657304000F67616D652D72756C652D656E +7472790300A4010170A50101720107656E7472696573A60104000F732D7365742D67616D652D72 +756C650300A70101720104736C6F747A04000F732D7365742D68656C642D6974656D0300A90101 +720803706F7321046E616D6573067461726765747304706F6F6C730B66696E616C2D7374617465 +73056A6F696E74731273656C656374696F6E2D7072696F726974797A12706C6163656D656E742D +7072696F726974797A040012732D7365742D6A69677361772D626C6F636B0300AB01017210086C +6F636174696F6E2106616374696F6E7A046D6F64657A046E616D6573086F66667365742D787D08 +6F66667365742D797D086F66667365742D7A7D0673697A652D787D0673697A652D797D0673697A +652D7A7D066D6972726F727A08726F746174696F6E7A086D657461646174617309696E74656772 +6974797604736565647805666C6167737D040015732D7365742D7374727563747572652D626C6F +636B0300AD01016D04057374617274036C6F67046661696C0661636365707404000F746573742D +626C6F636B2D6D6F64650300AF0101720308706F736974696F6E21046D6F6465B001076D657373 +61676573040010732D7365742D746573742D626C6F636B0300B101017201067461726765740104 +0011732D73706563746174652D656E746974790300B3010172010468616E647A04000B732D7377 +696E672D61726D0300B5010172010674617267657401040014732D74656C65706F72742D746F2D +656E746974790300B701016D0704696E6974057175657279037365740572657365740473617665 +066578706F72740372756E04001A746573742D696E7374616E63652D626C6F636B2D616374696F +6E0300B90101720301787A01797A017A7A04000F7661722D696E742D766563746F72330300BB01 +016D0407636C65617265640772756E6E696E670773756363657373066661696C656404001A7465 +73742D696E7374616E63652D626C6F636B2D7374617475730300BD010172060474657374D50004 +73697A65BC0108726F746174696F6E730F69676E6F72652D656E7469746965737F067374617475 +73BE010D6572726F722D6D657373616765D500040018746573742D696E7374616E63652D626C6F +636B2D646174610300BF0101720303706F732106616374696F6EBA010464617461C00104001C73 +2D746573742D696E7374616E63652D626C6F636B2D616374696F6E0300C101017206086C6F6361 +74696F6E210D69732D66726F6E742D746578747F066C696E652D3173066C696E652D3273066C69 +6E652D3373066C696E652D347304000D732D7570646174652D7369676E0300C301017204046861 +6E647A0873657175656E63657A03796177760570697463687604000A732D7573652D6974656D03 +00C5010172070468616E647A08706F736974696F6E2104666163657A0A637572736F722D706F73 +DA000C696E736964652D626C6F636B7F1769732D616761696E73742D776F726C642D626F726465 +727F0873657175656E63657A04000D732D7573652D6974656D2D6F6E0300C70101720107706179 +6C6F61647804001C7374617475732D732D7374617475732D70696E672D726571756573740300C9 +010172050475756964010375726C7304686173687306666F726365647F0E70726F6D70742D6D65 +7373616765D500040021636F6E6669672D632D636F6E6669672D6164642D7265736F757263652D +7061636B0300CB010172010F636F64652D6F662D636F6E6475637473040018636F6E6669672D63 +2D636F64652D6F662D636F6E647563740300CD0101720106726561736F6E7304001A636F6E6669 +672D632D636F6E6669672D646973636F6E6E6563740300CF01017201036B657973040017636F6E +6669672D632D636F6F6B69652D726571756573740300D101016F0273730170D301017201076465 +7461696C73D401040025636F6E6669672D632D636F6E6669672D637573746F6D2D7265706F7274 +2D64657461696C730300D5010172010866656174757265730C040016636F6E6669672D632D6665 +61747572652D666C6167730300D7010172010B6B6E6F776E2D7061636B730C040014636F6E6669 +672D632D6B6E6F776E2D7061636B730300D9010172010269647A040014636F6E6669672D632D63 +6F6E6669672D70696E670300DB01017202076368616E6E656C73046461746104040017636F6E66 +69672D632D706C7567696E2D6D6573736167650300DD010172020B72656769737472792D696473 +07656E74726965730C040016636F6E6669672D632D72656769737472792D646174610300DF0101 +6B010172010475756964E101040024636F6E6669672D632D636F6E6669672D72656D6F76652D72 +65736F757263652D7061636B0300E201017201056C696E6B730C04001C636F6E6669672D632D63 +6F6E6669672D7365727665722D6C696E6B730300E401017201066469616C6F677304001B636F6E +6669672D632D636F6E6669672D73686F772D6469616C6F670300E601017202036B657973077061 +796C6F616404040015636F6E6669672D632D73746F72652D636F6F6B69650300E8010172020468 +6F73747304706F72747A040011636F6E6669672D632D7472616E736665720300EA010172010474 +6167730C040014636F6E6669672D632D7570646174652D746167730300EC01017201036B657973 +04001C6C6F67696E2D632D6C6F67696E2D636F6F6B69652D726571756573740300EE0101720409 +7365727665722D6964730A7075626C69632D6B6579040C7665726966792D746F6B656E04137368 +6F756C642D61757468656E7469636174657F040014632D656E6372797074696F6E2D7265717565 +73740300F0010172010B6A736F6E2D726561736F6E730400186C6F67696E2D632D6C6F67696E2D +646973636F6E6E6563740300F2010172030A6D6573736167652D69647A076368616E6E656C7304 +646174610404001C6C6F67696E2D632D6C6F67696E2D706C7567696E2D726571756573740300F4 +01017201097468726573686F6C647A0400176C6F67696E2D632D7365742D636F6D707265737369 +6F6E0300F6010172010B73657175656E63652D69647A04001A632D61636B6E6F776C656467652D +626C6F636B2D6368616E67650300F8010172010A616374696F6E2D6261727304000C632D616374 +696F6E2D6261720300FA010172050475756964010375726C7304686173687306666F726365647F +0E70726F6D70742D6D657373616765D500040013632D6164642D7265736F757263652D7061636B +0300FC010172030B63617465676F72792D69647A0C7374617469737469632D69647A0576616C75 +657A0400097374617469737469630300FE010170FF01017201057374617473800204000D632D61 +776172642D73746174730300810201720309656E746974792D69647A086C6F636174696F6E210D +64657374726F792D73746167657D040019632D7365742D626C6F636B2D64657374726F792D7374 +61676503008302017203086C6F636174696F6E2106722D747970657A086E62742D646174610404 +0013632D626C6F636B2D656E746974792D6461746103008502017204086C6F636174696F6E2109 +616374696F6E2D69647D10616374696F6E2D706172616D657465727D0A626C6F636B2D74797065 +7A04000D632D626C6F636B2D6576656E7403008702017202086C6F636174696F6E210873746174 +652D69647A04000E632D626C6F636B2D75706461746503008902017205057469746C6573066865 +616C74687605636F6C6F727A086469766973696F6E7A05666C6167737D040014626F7373657665 +6E742D616374696F6E2D61646403008B0201720205636F6C6F727A0864697669646572737A0400 +1D626F73736576656E742D616374696F6E2D7570646174652D7374796C6503008D020171060361 +6464018C02000672656D6F766500000D7570646174652D6865616C74680176000B757064617465 +2D74696C650173000C7570646174652D7374796C65018E02000C7570646174652D666C61677301 +7D00040010626F73736576656E742D616374696F6E03008F020172020475756964010661637469 +6F6E900204000C632D626F73732D6576656E7403009102017202076368756E6B2D787A07636875 +6E6B2D7A7A04000E632D63656E7465722D6368756E6B030093020172020A646966666963756C74 +797D066C6F636B65647F040013632D6368616E67652D646966666963756C747903009502017201 +0A62617463682D73697A657A040011632D6368756E6B2D62617463682D656E6403009702017203 +076368756E6B2D787A076368756E6B2D7A7A0464617461040400116368756E6B2D62696F6D652D +656E7472790300990201709A02017201066368756E6B739B0204000F632D6368756E6B732D6269 +6F6D657303009C020172010572657365747F04000D632D636C6561722D7469746C6503009E0201 +72010773796E632D69647A040011632D636C6F73652D636F6E7461696E65720300A00201720209 +706C617965722D69647A076D6573736167657304000E632D636F6D6261742D64656174680300A2 +020172010E6475726174696F6E2D7469636B737A04000C632D636F6D6261742D656E640300A402 +0172020A73756767657374696F6E7307746F6F6C746970D500040012636F6D6D616E642D737567 +67657374696F6E0300A6020170A7020172040269647A0573746172747A066C656E6774687A076D +617463686573A802040015632D636F6D6D616E642D73756767657374696F6E730300A902017204 +046E616D65730D69732D65786563757461626C657F0F72656469726563742D746172676574DC00 +0A726573747269637465647F04001770726F746F2D6E6F64652D747970652D6C69746572616C03 +00AB02017202036D696EF300036D6178F300040013617267756D656E742D747970652D666C6F61 +740300AD02016B75017202036D696EAF02036D6178AF02040014617267756D656E742D74797065 +2D646F75626C650300B002017202036D696EDC00036D6178DC00040015617267756D656E742D74 +7970652D696E74656765720300B202016B78017202036D696EB402036D6178B402040012617267 +756D656E742D747970652D6C6F6E670300B50201720105666C6167737D040014617267756D656E +742D747970652D656E746974790300B70201720105666C6167737D04001A617267756D656E742D +747970652D73636F72652D686F6C6465720300B902017201036D696E7A040012617267756D656E +742D747970652D74696D650300BB020172010A6964656E7469666965727304001D617267756D65 +6E742D747970652D7265736F757263652D6F722D7461670300BD020172010A6964656E74696669 +657273040021617267756D656E742D747970652D7265736F757263652D6F722D7461672D6B6579 +0300BF020172010A6964656E74696669657273040016617267756D656E742D747970652D726573 +6F757263650300C1020172010A6964656E7469666965727304001A617267756D656E742D747970 +652D7265736F757263652D6B65790300C302016D030B73696E676C652D776F72640F71756F7461 +626C652D7068726173650D6772656564792D706872617365040019737472696E672D70726F746F +2D6172672D6265686176696F720300C50201713904626F6F6C000005666C6F617401AE02000664 +6F75626C6501B1020007696E746567657201B30200046C6F6E6701B6020006737472696E6701C6 +020006656E7469747901B802000C67616D652D70726F66696C65000009626C6F636B2D706F7300 +000A636F6C756D6E2D706F73000004766563330000047665633200000B626C6F636B2D73746174 +6500000F626C6F636B2D70726564696361746500000A6974656D2D737461636B00000E6974656D +2D707265646963617465000005636F6C6F720000096865782D636F6C6F72000009636F6D706F6E +656E740000057374796C650000076D65737361676500000C6E62742D636F6D706F756E64000007 +6E62742D7461670000086E62742D706174680000096F626A6563746976650000126F626A656374 +6976652D63726974657269610000096F7065726174696F6E0000087061727469636C6500000561 +6E676C65000008726F746174696F6E00000F73636F7265626F6172642D736C6F7400000C73636F +72652D686F6C64657201BA0200077377697A7A6C650000047465616D0000096974656D2D736C6F +7400000A6974656D2D736C6F74730000117265736F757263652D6C6F636174696F6E0000086675 +6E6374696F6E00000D656E746974792D616E63686F72000009696E742D72616E676500000B666C +6F61742D72616E676500000964696D656E73696F6E00000867616D656D6F646500000474696D65 +01BC02000F7265736F757263652D6F722D74616701BE0200137265736F757263652D6F722D7461 +672D6B657901C00200087265736F7572636501C202000C7265736F757263652D6B657901C40200 +117265736F757263652D73656C6563746F7200000F74656D706C6174652D6D6972726F72000011 +74656D706C6174652D726F746174696F6E0000096865696768746D617000000A6C6F6F742D7461 +626C6500000E6C6F6F742D70726564696361746500000D6C6F6F742D6D6F646966696572000006 +6469616C6F6700000475756964000004000D617267756D656E742D747970650300C702016D040A +61736B2D7365727665720B616C6C2D7265636970657310617661696C61626C652D736F756E6473 +1373756D6D6F6E61626C652D656E74697469657304001473756767657374696F6E2D70726F7669 +646572730300C902016BCA02017206046E616D65730D69732D65786563757461626C657F0F7265 +6469726563742D746172676574DC0006706172736572C802186F766572726964652D7375676765 +7374696F6E2D74797065CB020A726573747269637465647F04001870726F746F2D6E6F64652D74 +7970652D617267756D656E740300CC0201710304726F6F740000076C69746572616C01AC020008 +617267756D656E7401CD020004000F70726F746F2D6E6F64652D747970650300CE0201707A0172 +02086368696C6472656ED002096E6F64652D74797065CF0204000A70726F746F2D6E6F64650300 +D1020170D202017202056E6F646573D3020F726F6F742D6E6F64652D696E6465787A04000A632D +636F6D6D616E64730300D402017201036B657973040015632D706C61792D636F6F6B69652D7265 +71756573740300D60201720206616374696F6E7A07656E74726965730C040019632D637573746F +6D2D636861742D636F6D706C6574696F6E730300D802017202076368616E6E656C730464617461 +04040010632D637573746F6D2D7061796C6F61640300DA020172010764657461696C73D4010400 +1C632D706C61792D637573746F6D2D7265706F72742D64657461696C730300DC0201720509656E +746974792D69647A0E736F757263652D747970652D69647A0F736F757263652D63617573652D69 +647A10736F757263652D6469726563742D69647A0F736F757263652D706F736974696F6EDB0004 +000E632D64616D6167652D6576656E740300DE0201720303706F7321046E616D65730576616C75 +6573040013632D64656275672D626C6F636B2D76616C75650300E002016F027575017203096368 +756E6B2D706F73E202046E616D65730576616C756573040013632D64656275672D6368756E6B2D +76616C75650300E30201720309656E746974792D69647A046E616D65730576616C756573040014 +632D64656275672D656E746974792D76616C75650300E502017202046E616D6573046461746104 +04000D632D64656275672D6576656E740300E7020170780172020673616D706C65E9020B73616D +706C652D747970657A04000E632D64656275672D73616D706C650300EA020172020C7369676E61 +747572652D69647A097369676E61747572650504000D632D64656C6574652D636861740300EC02 +01720106726561736F6E73040011632D706C61792D646973636F6E6E6563740300EE0201720407 +6D6573736167657309636861742D747970657A0B73656E6465722D6E616D65730B746172676574 +2D6E616D65D500040018632D6469736775697365642D636861742D6D6573736167650300F00201 +720208706F736974696F6E7A0A73636F72652D6E616D6573040013632D646973706C61792D6F62 +6A6563746976650300F20201720209656E746974792D69647A09616E696D6174696F6E7D040012 +632D656E746974792D616E696D6174696F6E0300F402016D050E7377696E672D6D61696E2D6172 +6D096C656176652D6265640D7377696E672D6F666668616E640F637269746963616C2D65666665 +6374146D616769632D637269746963616C656666656374040009616E696D6174696F6E0300F602 +01720209656E746974792D69647A086D6574616461746104040015632D7365742D656E74697479 +2D6D657461646174610300F80201720609656E746974792D69647A08706F736974696F6EDA0005 +64656C7461DA00037961777605706974636876096F6E2D67726F756E647F040016632D656E7469 +74792D706F736974696F6E2D73796E630300FA020172060B736F756E642D6576656E74730E736F +756E642D63617465676F72797A09656E746974792D69647A06766F6C756D657605706974636876 +047365656478040015632D656E746974792D736F756E642D6566666563740300FC020172020965 +6E746974792D69647A0D656E746974792D7374617475737D04000F632D656E746974792D737461 +7475730300FE0201720209656E746974792D69647A0876656C6F6369747973040011632D656E74 +6974792D76656C6F63697479030080030172070663656E746572DA0006726164697573760B626C +6F636B2D636F756E747A096B6E6F636B6261636BDB00087061727469636C657A05736F756E6473 +19626C6F636B2D7061727469636C65732D706F6F6C2D73697A657A04000B632D6578706C6F7369 +6F6E03008203017202056576656E747D0576616C75657604000C632D67616D652D6576656E7403 +008403016D0E1A6E6F2D7265737061776E2D626C6F636B2D617661696C61626C650D626567696E +2D7261696E696E670B656E642D7261696E696E67106368616E67652D67616D652D6D6F64650877 +696E2D67616D650A64656D6F2D6576656E74106172726F772D6869742D706C6179657211726169 +6E2D6C6576656C2D6368616E6765147468756E6465722D6C6576656C2D6368616E67651C706C61 +792D707566666572666973682D737472696E672D736F756E6422706C61792D656C6465722D6775 +61726469616E2D6D6F622D617070656172616E636516656E61626C65642D7265737061776E2D73 +637265656E106C696D697465642D6372616674696E671473746172742D77616974696E672D6368 +756E6B7304000A67616D652D6576656E74030086030172010572756C6573D401040012632D6761 +6D652D72756C652D76616C7565730300880301720403706F732105636F6C6F727A056C6162656C +730B6475726174696F6E2D6D737A040019632D67616D652D746573742D686967686C696768742D +706F7303008A0301720209656E746974792D69647A08686561642D7961777D04000A632D686561 +642D726F7403008C0301720209656E746974792D69647A0379617776040010632D687572742D61 +6E696D6174696F6E03008E03017208017875017A750C6F6C642D6469616D65746572750C6E6577 +2D6469616D65746572750573706565647818706F7274616C2D74656C65706F72742D626F756E64 +6172797A0E7761726E696E672D626C6F636B737A0C7761726E696E672D74696D657A040019632D +696E697469616C697A652D776F726C642D626F72646572030090030172020567726F7570730863 +6F6F6C646F776E7A04000F632D6974656D2D636F6F6C646F776E030092030172010D6B6565702D +616C6976652D69647804000C632D6B6565702D616C69766503009403017204056576656E747A08 +6C6F636174696F6E2104646174617A1764697361626C652D72656C61746976652D766F6C756D65 +7F04000D632D6C6576656C2D6576656E74030096030170040172070B74727573742D6564676573 +7F0E736B792D6C696768742D6D61736BE90210626C6F636B2D6C696768742D6D61736BE9021465 +6D7074792D736B792D6C696768742D6D61736BE90216656D7074792D626C6F636B2D6C69676874 +2D6D61736BE90210736B792D6C696768742D617272617973980312626C6F636B2D6C696768742D +617272617973980304000A6C696768742D6461746103009903017203076368756E6B2D787A0763 +68756E6B2D7A7A0A6C696768742D646174619A0304000E632D6C696768742D7570646174650300 +9B030172050969636F6E2D747970657A01787D017A7D09646972656374696F6E7D0C646973706C +61792D6E616D65D5000400086D61702D69636F6E03009D0301720507636F6C756D6E737D04726F +77737D01787D017A7D0464617461040400096D61702D706174636803009F0301709E03016BA103 +016BA003017206066D61702D69647A057363616C657D11747261636B696E672D706F736974696F +6E7F066C6F636B65647F0569636F6E73A2030464617461A30304000F632D6D61702D6974656D2D +646174610300A40301720A0B626173652D636F73742D6173066F75747075747306636F73742D62 +D5000A7265776172642D6578707F04757365737A086D61782D757365737A0278707A0D73706563 +69616C2D70726963657A1070726963652D6D756C7469706C696572760664656D616E647A04000E +6D65726368616E742D6F666665720300A6030170A7030172060977696E646F772D69647A066F66 +66657273A8030E76696C6C616765722D6C6576656C7A0A657870657269656E63657A1369732D72 +6567756C61722D76696C6C616765727F0B63616E2D726573746F636B7F040011632D6D65726368 +616E742D6F66666572730300A90301720508706F736974696F6EDA00086D6F76656D656E74DA00 +037961777605706974636876067765696768747604000D6D696E65636172742D737465700300AB +030170AC0301720209656E746974792D69647A057374657073AD0304001B632D6D6F76652D6D69 +6E65636172742D616C6F6E672D747261636B0300AE03017205017875017975017A750379617776 +0570697463687604000E632D6D6F76652D76656869636C650300B003016F0221730170B2030172 +030D6368756E6B2D73656374696F6EDA001673757070726573732D6C696768742D757064617465 +737F0775706461746573B303040014632D6D756C74692D626C6F636B2D7570646174650300B403 +0172010468616E647A04000B632D6F70656E2D626F6F6B0300B6030172030977696E646F772D69 +647D0A736C6F742D636F756E747A09656E746974792D69647A040013632D6F70656E2D6D6F756E +742D73637265656E0300B8030172030773796E632D69647A0B77696E646F772D747970657A0C77 +696E646F772D7469746C657304000D632D6F70656E2D73637265656E0300BA03017202086C6F63 +6174696F6E210D69732D66726F6E742D746578747F040012632D6F70656E2D7369676E2D656469 +746F720300BC030172080B666F7263652D737061776E7F09696D706F7274616E747F08706F7369 +74696F6EDA00066F6666736574DA00096D61782D7370656564760E7061727469636C652D636F75 +6E747A0B7061727469636C652D69647A04646174610404000A632D7061727469636C650300BE03 +0172010269647A04000B632D706C61792D70696E670300C003017201077061796C6F6164780400 +0F632D70696E672D726573706F6E73650300C2030172020977696E646F772D69647D0972656369 +70652D696473040014632D706C6163652D67686F73742D7265636970650300C40301720305666C +6167737D0C666C79696E672D7370656564760D6669656C642D6F662D7669657776040012632D70 +6C617965722D6162696C69746965730300C6030172040A73657373696F6E2D6964010A65787069 +7265732D6174780A7075626C69632D6B657904097369676E617475726504040009696E69742D63 +6861740300C8030172020269647A097369676E61747572650504001070726576696F75732D6D65 +73736167650300CA030171030C706173732D7468726F75676800000E66756C6C792D66696C7465 +7265640000127061727469616C6C792D66696C746572656401E9020004000B66696C7465722D74 +7970650300CC030170CB0301720D0C676C6F62616C2D696E6465787A0673656E6465720105696E +6465787A116D6573736167652D7369676E617475726505076D657373616765730974696D657374 +616D70780473616C74781170726576696F75732D6D65737361676573CE0310756E7369676E6564 +2D636F6E74656E74D5000B66696C7465722D74797065CD0309636861742D747970657A0B73656E +6465722D6E616D65730B7461726765742D6E616D65D500040015632D706C617965722D63686174 +2D6D6573736167650300CF03016F027A7A016BD1030172050B66726F6D2D616E63686F727A0874 +61726765742D7875087461726765742D7975087461726765742D7A7506656E74697479D2030400 +10632D706C617965722D6C6F6F6B2D61740300D3030172060B74656C65706F72742D69647A0870 +6F736974696F6EDA000564656C7461DA000379617776057069746368760972656C617469766573 +0C040011632D706C617965722D706F736974696F6E0300D50301700101720107706C6179657273 +D703040014632D72656D6F76652D706C617965722D696E666F0300D80301720203796177760570 +6974636876040011632D706C617965722D726F746174696F6E0300DA03016F027321016BDC0301 +72090964696D656E73696F6E730B6861736865642D73656564780967616D652D6D6F64657D1170 +726576696F75732D67616D656D6F64657D0564656275677F0769732D666C61747F146465617468 +2D64696D656E73696F6E2D6E616D65DD030F706F7274616C2D636F6F6C646F776E7A087365616C +6576656C7A040011706C617965722D737061776E2D646174610300DE0301720C09656E74697479 +2D69647A0B69732D68617264636F72657F0F64696D656E73696F6E2D6E616D65730C0B6D61782D +706C61796572737A0D766965772D64697374616E63657A1273696D756C617465642D6469737461 +6E63657A12726564756365642D64656275672D696E666F7F16656E61626C65642D726573706177 +6E2D73637265656E7F106C696D697465642D6372616674696E677F0A737061776E2D64617461DF +030B6F6E6C696E652D6D6F64657F13656E666F7263652D7365637572652D636861747F04000763 +2D6C6F67696E0300E0030172040E64696D656E73696F6E2D6E616D6573086C6F636174696F6E21 +037961777605706974636876040017632D706C617965722D737061776E2D706F736974696F6E03 +00E20301720409656E746974792D69647A07782D706F7765727507792D706F77657275077A2D70 +6F77657275040012632D70726F6A656374696C652D706F7765720300E403017201077265706C61 +63657F040011632D7265636970652D626F6F6B2D6164640300E6030172010772656369706573D0 +02040014632D7265636970652D626F6F6B2D72656D6F76650300E8030172080D6372616674696E +672D6F70656E7F126372616674696E672D66696C746572696E677F0C6675726E6163652D6F7065 +6E7F116675726E6163652D66696C746572696E677F12626C6173742D6675726E6163652D6F7065 +6E7F17626C6173742D6675726E6163652D66696C746572696E677F0B736D6F6B65722D6F70656E +7F10736D6F6B65722D66696C746572696E677F040016632D7265636970652D626F6F6B2D736574 +74696E67730300EA030172010A656E746974792D696473D002040011632D72656D6F76652D656E +7469746965730300EC0301720209656E746974792D69647A096566666563742D69647A04001363 +2D72656D6F76652D6D6F622D6566666563740300EE030172010475756964E101040016632D7265 +6D6F76652D7265736F757263652D7061636B0300F0030172020B656E746974792D6E616D65730E +6F626A6563746976652D6E616D65D50004000D632D72657365742D73636F72650300F203017202 +11706C617965722D737061776E2D696E666FDF0309646174612D6B6570747D040009632D726573 +7061776E0300F403017201067461622D6964D500040019632D73656C6563742D616476616E6365 +6D656E74732D7461620300F603017202046D6F7464730B69636F6E2D626173653634D50004000D +632D7365727665722D646174610300F803017201056C696E6B730C040013632D706C61792D7365 +727665722D6C696E6B730300FA03017202017875017A75040013632D7365742D626F726465722D +63656E7465720300FC030172030C6F6C642D6469616D65746572750C6E65772D6469616D657465 +727505737065656478040016632D7365742D626F726465722D6C6572702D73697A650300FE0301 +7201086469616D6574657275040011632D7365742D626F726465722D73697A6503008004017201 +0C7761726E696E672D74696D657A04001A632D7365742D626F726465722D7761726E696E672D64 +656C6179030082040172010E7761726E696E672D626C6F636B737A04001D632D7365742D626F72 +6465722D7761726E696E672D64697374616E6365030084040172010963616D6572612D69647A04 +000C632D7365742D63616D65726103008604017201067261646975737A040018632D7365742D63 +68756E6B2D63616368652D726164697573030088040172040977696E646F772D69647A08737461 +74652D69647A09736C6F742D646174610C0C636172726965642D6974656D73040017632D736574 +2D636F6E7461696E65722D636F6E74656E7403008A040172030977696E646F772D69647A087072 +6F70657274797A0576616C75657A040018632D7365742D636F6E7461696E65722D70726F706572 +747903008C040172040977696E646F772D69647D0873746174652D69647A04736C6F747A09736C +6F742D6461746173040014632D7365742D636F6E7461696E65722D736C6F7403008E0401720105 +737461636B73040011632D7365742D637572736F722D6974656D03009004017203126174746163 +6865642D656E746974792D69647A11686F6C64696E672D656E746974792D69647A056C65617368 +7F040011632D7365742D656E746974792D6C696E6B03009204016F027D73017094040172020965 +6E746974792D69647A0965717569706D656E74950404000F632D7365742D65717569706D656E74 +030096040172030870726F677265737376056C6576656C7A10746F74616C2D657870657269656E +63657A040010632D7365742D657870657269656E636503009804017203066865616C7468760466 +6F6F647A0F666F6F642D73617475726174696F6E7604000C632D7365742D6865616C746803009A +0401720104736C6F747D040013632D7365742D73656C65637465642D736C6F7403009C04017202 +09656E746974792D69647A0A70617373656E67657273D002040010632D7365742D70617373656E +6765727303009E0401720204736C6F747A046974656D73040016632D7365742D706C617965722D +696E76656E746F72790300A004016D05066372656174650672656D6F7665067570646174650B61 +64642D706C61796572730E72656D6F76652D706C617965727304000B7465616D2D6D6574686F64 +0300A2040172070C646973706C61792D6E616D6573076F7074696F6E737D126E616D657461672D +7669736962696C697479730E636F6C6C6973696F6E2D72756C657305636F6C6F727A0D706C6179 +65722D707265666978730D706C617965722D7375666669787304000F7465616D2D706172616D65 +746572730300A404016BA504017204097465616D2D6E616D6573066D6574686F64A3040A706172 +616D6574657273A60407706C61796572730C040011632D7365742D706C617965722D7465616D03 +00A7040172011373696D756C6174696F6E2D64697374616E63657A040019632D7365742D73696D +756C6174696F6E2D64697374616E63650300A904016F047A7876760170AB040172020967616D65 +2D74696D65780D636C6F636B2D75706461746573AC0404000D632D7570646174652D74696D6503 +00AD04017201057469746C657304000C632D7469746C652D746578740300AF040172030D666164 +652D696E2D7469636B737A0A737461792D7469636B737A0E666164652D6F75742D7469636B737A +040011632D7469746C652D616E696D6174696F6E0300B104017201066469616C6F677304001263 +2D706C61792D73686F772D6469616C6F670300B3040172060B736F756E642D6576656E74730E73 +6F756E642D63617465676F72797A08706F736974696F6EDA0006766F6C756D6576057069746368 +7604736565647504000E632D736F756E642D6566666563740300B50401720909656E746974792D +69647A0B656E746974792D757569640106722D747970657A08706F736974696F6EDA000876656C +6F63697479730570697463687D037961777D08686561642D7961777D04646174617A04000E632D +737061776E2D656E746974790300B70401720909656E746974792D69647A0B656E746974792D75 +7569640106722D747970657A08706F736974696F6EDA00037961777D0570697463687D08686561 +642D7961777D0876656C6F6369747973086D6574616461746105040015632D737061776E2D6C69 +76696E672D656E746974790300B90401720609656E746974792D69647A04757569640105746974 +6C65730776617269616E747A086C6F636174696F6E2109646972656374696F6E7D040010632D73 +7061776E2D7061696E74696E670300BB0401720208736F756E642D6964D5000863617465676F72 +79D50004000C632D73746F702D736F756E640300BD04017202036B657973077061796C6F616404 +04000E632D73746F72652D636F6F6B69650300BF04017201087375627469746C657304000A632D +7375627469746C650300C10401720207636F6E74656E7473076F7665726C61797F040015632D73 +797374656D2D636861742D6D6573736167650300C304017202066865616465727306666F6F7465 +727304000A632D7461622D6C6973740300C5040172020E7472616E73616374696F6E2D69647A09 +6E62742D627974657304040014632D7461672D71756572792D726573706F6E73650300C7040172 +0309656E746974792D69647A13636F6C6C6563746F722D656E746974792D69647A0C737461636B +2D616D6F756E747A040012632D74616B652D6974656D2D656E746974790300C90401720709656E +746974792D69647A08706F736974696F6EDA000564656C7461DA00037961777605706974636876 +0972656C6174697665730C096F6E2D67726F756E647F040011632D74656C65706F72742D656E74 +6974790300CB0401720303706F7321067374617475737A076D657373616765D50004001C632D74 +6573742D696E7374616E63652D626C6F636B2D7374617475730300CD04017202097469636B2D72 +617465760969732D66726F7A656E7F04000F632D7469636B696E672D73746174650300CF040172 +010A7469636B2D73746570737A04000E632D7469636B696E672D737465700300D1040172020468 +6F73747304706F72747A04000A632D7472616E736665720300D30401720201787A017A7A04000E +632D756E6C6F61642D6368756E6B0300D5040172050572657365747F0561646465640C0772656D +6F7665640C0870726F67726573730C1173686F772D616476616E63656D656E74737F040015632D +7570646174652D616476616E63656D656E74730300D7040172030269647306616D6F756E747509 +6F7065726174696F6E7D0400126174747269627574652D6D6F6469666965720300D9040170DA04 +0172030269647A0576616C756575096D6F64696669657273DB0404000870726F70657274790300 +DC040170DD0401720504757569640108757365726E616D65730A70726F70657274696573DE0415 +7374726963742D6572726F722D68616E646C696E677F0A73657373696F6E2D69640104000F632D +6C6F67696E2D737563636573730300DF04017202046E616D65730A70726F70657274696573DE04 +040018706C617965722D616374696F6E2D6164642D706C617965720300E104016BC9030171080A +6164642D706C6179657201E204000F696E697469616C697A652D6368617401E304001075706461 +74652D67616D652D6D6F6465017A000D7570646174652D6C6973746564017F000E757064617465 +2D6C6174656E6379017A00137570646174652D646973706C61792D6E616D6501D5000011757064 +6174652D6C6973742D6F72646572017A000A7570646174652D686174017F0004000D706C617965 +722D616374696F6E0300E4040170E50401720204757569640107616374696F6E73E60404000670 +6C617965720300E7040170E80401720207616374696F6E737D07706C6179657273E90404001463 +2D706C617965722D696E666F2D7570646174650300EA0401720209656E746974792D69647A0A70 +726F70657274696573DE04040013632D7570646174652D617474726962757465730300EC040172 +0309656E746974792D69647A0564656C7461DA00096F6E2D67726F756E647F040013632D757064 +6174652D656E746974792D706F730300EE0401720509656E746974792D69647A0564656C7461DA +00037961777D0570697463687D096F6E2D67726F756E647F040017632D7570646174652D656E74 +6974792D706F732D726F740300F00401720409656E746974792D69647A037961777D0570697463 +687D096F6E2D67726F756E647F040013632D7570646174652D656E746974792D726F740300F204 +01720509656E746974792D69647A096566666563742D69647A09616D706C69666965727A086475 +726174696F6E7A05666C6167737D040013632D7570646174652D6D6F622D6566666563740300F4 +040172050E6F626A6563746976652D6E616D6573046D6F64657D0C646973706C61792D6E616D65 +730B72656E6465722D747970657A0D6E756D6265722D666F726D6174D500040013632D75706461 +74652D6F626A656374697665730300F604016D03036164640672656D6F76650675706461746504 +00046D6F64650300F804016D0207696E74656765720668656172747304000B72656E6465722D74 +7970650300FA04017201087261772D6461746104040010632D7570646174652D72656369706573 +0300FC040172050B656E746974792D6E616D65730E6F626A6563746976652D6E616D6573057661 +6C75657A0C646973706C61792D6E616D65D5000D6E756D6265722D666F726D6174D50004000E63 +2D7570646174652D73636F72650300FE0401720104746167730C040012632D7570646174652D74 +6167732D706C61790300800501720209656E746974792D69647A086C6F636174696F6E21040009 +632D7573652D62656403008205016D0305747261636B07756E747261636B067570646174650400 +12776179706F696E742D6F7065726174696F6E0300840501720201787A017A7A04001577617970 +6F696E742D7461726765742D6368756E6B0300860501710408706F736974696F6E012100056368 +756E6B0187050007617A696D75746801760005656D707479000004000F776179706F696E742D74 +617267657403008805017202057374796C65D50005636F6C6F727A04000D776179706F696E742D +69636F6E03008A05016B8B050172030A6964656E746966696572010469636F6E8C050674617267 +65748905040010747261636B65642D776179706F696E7403008D05017202096F7065726174696F +6E850508776179706F696E748E0504000A632D776179706F696E7403008F05017204056576656E +747A086C6F636174696F6E2104646174617A1764697361626C652D72656C61746976652D766F6C +756D657F04000D632D776F726C642D6576656E7403009105017201077061796C6F616478040016 +7374617475732D632D70696E672D726573706F6E7365030093050172010D6A736F6E2D72657370 +6F6E7365730400187374617475732D632D7374617475732D726573706F6E736503009505017156 +1F636F6E6669672D732D6163636570742D636F64652D6F662D636F6E64756374000022636F6E66 +69672D732D61636B6E6F776C656467652D66696E6973682D636F6E666967000022636F6E666967 +2D732D636C69656E742D696E666F726D6174696F6E2D636F6E6669670103001F636F6E6669672D +732D636F6E6669672D636F6F6B69652D726573706F6E73650107001C636F6E6669672D732D6375 +73746F6D2D636C69636B2D616374696F6E01090013636F6E6669672D732D6B6565702D616C6976 +65010B0014636F6E6669672D732D6B6E6F776E2D7061636B73010E0017636F6E6669672D732D70 +6C7567696E2D6D65737361676501100014636F6E6669672D732D636F6E6669672D706F6E670112 +001D636F6E6669672D732D636F6E6669672D7265736F757263652D7061636B0116001D6C6F6769 +6E2D732D6C6F67696E2D636F6F6B69652D726573706F6E73650118001A6C6F67696E2D732D6C6F +67696E2D61636B6E6F776C65646765640000136C6F67696E2D732D6C6F67696E2D737461727401 +1C001D6C6F67696E2D732D6C6F67696E2D706C7567696E2D726573706F6E7365011E0008732D61 +747461636B01200018732D626C6F636B2D656E746974792D7461672D717565727901230016732D +62756E646C652D6974656D2D73656C656374656401250013732D6368616E67652D646966666963 +756C747901270012732D6368616E67652D67616D652D6D6F64650129000A732D636861742D6163 +6B012B000E732D636861742D636F6D6D616E64012D0015732D636861742D636F6D6D616E642D73 +69676E65640132000E732D636861742D6D6573736167650134000D732D6368756E6B2D62617463 +680136000C732D636C69636B2D736C6F74013C0010732D636C69656E742D636F6D6D616E64013E +0019732D636C69656E742D696E666F726D6174696F6E2D706C617901C0000011732D636C69656E +742D7469636B2D656E64000011732D636C6F73652D636F6E7461696E657201C2000014732D636F +6D6D616E642D73756767657374696F6E01C400001C732D636F6E66696775726174696F6E2D6163 +6B6E6F776C6564676564000018732D636F6E7461696E65722D627574746F6E2D636C69636B01C8 +00001E732D636F6E7461696E65722D736C6F742D73746174652D6368616E67656401CA00001173 +2D636F6F6B69652D726573706F6E736501CC000015732D637573746F6D2D636C69636B2D616374 +696F6E01CE000010732D637573746F6D2D7061796C6F616401D000001B732D64656275672D7361 +6D706C652D737562736372697074696F6E01D200001C732D64656275672D737562736372697074 +696F6E2D7265717565737401D400000B732D656469742D626F6F6B01D7000012732D656E746974 +792D7461672D717565727901D900000A732D696E74657261637401DE000011732D6A6967736177 +2D67656E657261746501E200000C732D6B6565702D616C69766501E4000011732D6C6F636B2D64 +6966666963756C747901E600000E732D6D6F76652D76656869636C6501E800000D732D70616464 +6C652D626F617401EA000016732D7069636B2D6974656D2D66726F6D2D626C6F636B01EC000017 +732D7069636B2D6974656D2D66726F6D2D656E7469747901EE000013732D706C61792D70696E67 +2D7265717565737401F000000E732D706C6163652D72656369706501F2000012732D706C617965 +722D6162696C697469657301F500000F732D706C617965722D616374696F6E01F7000010732D70 +6C617965722D636F6D6D616E6401FD000013732D7365742D706C617965722D67726F756E6401FF +00000E732D706C617965722D696E707574018101000F732D706C617965722D6C6F616465640000 +11732D706C617965722D706F736974696F6E018301001A732D706C617965722D706F736974696F +6E2D726F746174696F6E0185010011732D706C617965722D726F746174696F6E0187010010732D +706C617965722D73657373696F6E018901000B732D706C61792D706F6E67018B01001D732D7265 +636970652D626F6F6B2D6368616E67652D73657474696E6773018D010019732D7265636970652D +626F6F6B2D7365656E2D726563697065018F01000D732D72656E616D652D6974656D0191010014 +732D706C61792D7265736F757263652D7061636B0195010012732D7365656E2D616476616E6365 +6D656E74019701000E732D73656C6563742D7472616465019901000C732D7365742D626561636F +6E019B010013732D7365742D636F6D6D616E642D626C6F636B019D010016732D7365742D636F6D +6D616E642D6D696E656361727401A1010013732D7365742D63726561746976652D736C6F7401A3 +01000F732D7365742D67616D652D72756C6501A801000F732D7365742D68656C642D6974656D01 +AA010012732D7365742D6A69677361772D626C6F636B01AC010015732D7365742D737472756374 +7572652D626C6F636B01AE010010732D7365742D746573742D626C6F636B01B2010011732D7370 +6563746174652D656E7469747901B401000B732D7377696E672D61726D01B6010014732D74656C +65706F72742D746F2D656E7469747901B801001C732D746573742D696E7374616E63652D626C6F +636B2D616374696F6E01C201000D732D7570646174652D7369676E01C401000A732D7573652D69 +74656D01C601000D732D7573652D6974656D2D6F6E01C801001C7374617475732D732D73746174 +75732D70696E672D7265717565737401CA0100177374617475732D732D7374617475732D726571 +75657374000007756E6B6E6F776E0000040012736572766572626F756E642D7061636B65740300 +97050171A60121636F6E6669672D632D636F6E6669672D6164642D7265736F757263652D706163 +6B01CC01001C636F6E6669672D632D636F6E6669672D636C6561722D6469616C6F67000018636F +6E6669672D632D636F64652D6F662D636F6E6475637401CE01001A636F6E6669672D632D636F6E +6669672D646973636F6E6E65637401D0010017636F6E6669672D632D636F6F6B69652D72657175 +65737401D2010025636F6E6669672D632D636F6E6669672D637573746F6D2D7265706F72742D64 +657461696C7301D6010016636F6E6669672D632D666561747572652D666C61677301D801001663 +6F6E6669672D632D66696E6973682D636F6E666967000014636F6E6669672D632D6B6E6F776E2D +7061636B7301DA010014636F6E6669672D632D636F6E6669672D70696E6701DC010017636F6E66 +69672D632D706C7567696E2D6D65737361676501DE010016636F6E6669672D632D726567697374 +72792D6461746101E0010024636F6E6669672D632D636F6E6669672D72656D6F76652D7265736F +757263652D7061636B01E301001A636F6E6669672D632D636F6E6669672D72657365742D636861 +7400001C636F6E6669672D632D636F6E6669672D7365727665722D6C696E6B7301E501001B636F +6E6669672D632D636F6E6669672D73686F772D6469616C6F6701E7010015636F6E6669672D632D +73746F72652D636F6F6B696501E9010011636F6E6669672D632D7472616E7366657201EB010014 +636F6E6669672D632D7570646174652D7461677301ED01001C6C6F67696E2D632D6C6F67696E2D +636F6F6B69652D7265717565737401EF0100186C6F67696E2D632D6C6F67696E2D646973636F6E +6E65637401F301001C6C6F67696E2D632D6C6F67696E2D706C7567696E2D7265717565737401F5 +0100176C6F67696E2D632D7365742D636F6D7072657373696F6E01F701001A632D61636B6E6F77 +6C656467652D626C6F636B2D6368616E676501F901000C632D616374696F6E2D62617201FB0100 +13632D6164642D7265736F757263652D7061636B01FD01000D632D61776172642D737461747301 +82020019632D7365742D626C6F636B2D64657374726F792D73746167650184020013632D626C6F +636B2D656E746974792D64617461018602000D632D626C6F636B2D6576656E74018802000E632D +626C6F636B2D757064617465018A02000C632D626F73732D6576656E740192020012632D62756E +646C652D64656C696D6974657200000E632D63656E7465722D6368756E6B0194020013632D6368 +616E67652D646966666963756C74790196020011632D6368756E6B2D62617463682D656E640198 +020013632D6368756E6B2D62617463682D737461727400000F632D6368756E6B732D62696F6D65 +73019D020013632D706C61792D636C6561722D6469616C6F6700000D632D636C6561722D746974 +6C65019F020011632D636C6F73652D636F6E7461696E657201A102000E632D636F6D6261742D64 +6561746801A302000E632D636F6D6261742D656E74657200000C632D636F6D6261742D656E6401 +A5020015632D636F6D6D616E642D73756767657374696F6E7301AA02000A632D636F6D6D616E64 +7301D5020015632D706C61792D636F6F6B69652D7265717565737401D7020019632D637573746F +6D2D636861742D636F6D706C6574696F6E7301D9020010632D637573746F6D2D7061796C6F6164 +01DB02001C632D706C61792D637573746F6D2D7265706F72742D64657461696C7301DD02000E63 +2D64616D6167652D6576656E7401DF020013632D64656275672D626C6F636B2D76616C756501E1 +020013632D64656275672D6368756E6B2D76616C756501E4020014632D64656275672D656E7469 +74792D76616C756501E602000D632D64656275672D6576656E7401E802000E632D64656275672D +73616D706C6501EB02000D632D64656C6574652D6368617401ED020011632D706C61792D646973 +636F6E6E65637401EF020018632D6469736775697365642D636861742D6D65737361676501F102 +0013632D646973706C61792D6F626A65637469766501F3020012632D656E746974792D616E696D +6174696F6E01F5020015632D7365742D656E746974792D6D6574616461746101F9020015632D65 +6E746974792D736F756E642D65666665637401FD02000F632D656E746974792D73746174757301 +FF020011632D656E746974792D76656C6F63697479018103000B632D6578706C6F73696F6E0183 +03000C632D67616D652D6576656E740185030012632D67616D652D72756C652D76616C75657301 +89030019632D67616D652D746573742D686967686C696768742D706F73018B03000A632D686561 +642D726F74018D030010632D687572742D616E696D6174696F6E018F030019632D696E69746961 +6C697A652D776F726C642D626F72646572019103000F632D6974656D2D636F6F6C646F776E0193 +03000C632D6B6565702D616C697665019503000D632D6C6576656C2D6576656E74019703000E63 +2D6C696768742D757064617465019C030007632D6C6F67696E01E1030018632D6C6F772D646973 +6B2D73706163652D7761726E696E6700000F632D6D61702D6974656D2D6461746101A503001163 +2D6D65726368616E742D6F666665727301AA03001B632D6D6F76652D6D696E65636172742D616C +6F6E672D747261636B01AF03000E632D6D6F76652D76656869636C6501B1030014632D6D756C74 +692D626C6F636B2D75706461746501B503000B632D6F70656E2D626F6F6B01B7030013632D6F70 +656E2D6D6F756E742D73637265656E01B903000D632D6F70656E2D73637265656E01BB03001263 +2D6F70656E2D7369676E2D656469746F7201BD03000A632D7061727469636C6501BF03000B632D +706C61792D70696E6701C103000F632D70696E672D726573706F6E736501C3030014632D706C61 +63652D67686F73742D72656369706501C5030012632D706C617965722D6162696C697469657301 +C7030015632D706C617965722D636861742D6D65737361676501D0030014632D706C617965722D +696E666F2D75706461746501EB040010632D706C617965722D6C6F6F6B2D617401D4030011632D +706C617965722D706F736974696F6E01D6030014632D72656D6F76652D706C617965722D696E66 +6F01D9030011632D706C617965722D726F746174696F6E01DB030017632D706C617965722D7370 +61776E2D706F736974696F6E01E3030012632D70726F6A656374696C652D706F77657201E50300 +11632D7265636970652D626F6F6B2D61646401E7030014632D7265636970652D626F6F6B2D7265 +6D6F766501E9030016632D7265636970652D626F6F6B2D73657474696E677301EB030011632D72 +656D6F76652D656E74697469657301ED030013632D72656D6F76652D6D6F622D65666665637401 +EF030016632D72656D6F76652D7265736F757263652D7061636B01F103000D632D72657365742D +73636F726501F3030009632D7265737061776E01F5030019632D73656C6563742D616476616E63 +656D656E74732D74616201F703000D632D7365727665722D6461746101F9030013632D706C6179 +2D7365727665722D6C696E6B7301FB030013632D7365742D626F726465722D63656E74657201FD +030016632D7365742D626F726465722D6C6572702D73697A6501FF030011632D7365742D626F72 +6465722D73697A65018104001A632D7365742D626F726465722D7761726E696E672D64656C6179 +018304001D632D7365742D626F726465722D7761726E696E672D64697374616E6365018504000C +632D7365742D63616D6572610187040018632D7365742D6368756E6B2D63616368652D72616469 +75730189040017632D7365742D636F6E7461696E65722D636F6E74656E74018B040018632D7365 +742D636F6E7461696E65722D70726F7065727479018D040014632D7365742D636F6E7461696E65 +722D736C6F74018F040011632D7365742D637572736F722D6974656D0191040011632D7365742D +656E746974792D6C696E6B019304000F632D7365742D65717569706D656E740197040010632D73 +65742D657870657269656E6365019904000C632D7365742D6865616C7468019B040010632D7365 +742D70617373656E67657273019F040016632D7365742D706C617965722D696E76656E746F7279 +01A1040011632D7365742D706C617965722D7465616D01A8040019632D7365742D73696D756C61 +74696F6E2D64697374616E636501AA04000D632D7570646174652D74696D6501AE04000C632D74 +69746C652D7465787401B0040011632D7469746C652D616E696D6174696F6E01B2040012632D70 +6C61792D73686F772D6469616C6F6701B404000E632D736F756E642D65666665637401B604000E +632D737061776E2D656E7469747901B8040015632D737061776E2D6C6976696E672D656E746974 +7901BA040010632D737061776E2D7061696E74696E6701BC040015632D73746172742D636F6E66 +696775726174696F6E00000C632D73746F702D736F756E6401BE04000E632D73746F72652D636F +6F6B696501C004000A632D7375627469746C6501C204000A632D7461622D6C69737401C6040014 +632D7461672D71756572792D726573706F6E736501C8040012632D74616B652D6974656D2D656E +7469747901CA040011632D74656C65706F72742D656E7469747901CC04001C632D746573742D69 +6E7374616E63652D626C6F636B2D73746174757301CE04000F632D7469636B696E672D73746174 +6501D004000E632D7469636B696E672D7374657001D204000A632D7472616E7366657201D40400 +0E632D756E6C6F61642D6368756E6B01D6040015632D7570646174652D616476616E63656D656E +747301D8040013632D7570646174652D6174747269627574657301ED040013632D757064617465 +2D656E746974792D706F7301EF040017632D7570646174652D656E746974792D706F732D726F74 +01F1040013632D7570646174652D656E746974792D726F7401F3040013632D7570646174652D6D +6F622D65666665637401F5040013632D7570646174652D6F626A6563746976657301F704001063 +2D7570646174652D7265636970657301FD04000E632D7570646174652D73636F726501FF040009 +632D7573652D626564018305000A632D776179706F696E74019005000D632D776F726C642D6576 +656E7401920500167374617475732D632D70696E672D726573706F6E7365019405001873746174 +75732D632D7374617475732D726573706F6E73650196050007756E6B6E6F776E0000040012636C +69656E74626F756E642D7061636B65740300990503002170756D706B696E3A706C7567696E2F6A +6176612D7061636B65747340302E312E3005390142D20302030201340400047575696403000001 +6D3D046E6F6E65046A756D7004687572740564656174680F73746172742D61747461636B696E67 +0E73746F702D61747461636B696E670D74616D696E672D6661696C65641074616D696E672D7375 +636365656465640D7368616B652D7765746E657373096561742D67726173730F66697368686F6F +6B2D627562626C651166697368686F6F6B2D666973682D706F731266697368686F6F6B2D686F6F +6B2D74696D650E66697368686F6F6B2D74656173650D73717569642D666C6565696E67117A6F6D +6269652D636F6E76657274696E670C706C61792D616D6269656E740B737061776E2D616C697665 +1273746172742D6F666665722D666C6F7765721173746F702D6F666665722D666C6F7765720B6C +6F76652D6865617274730E76696C6C616765722D616E6772790E76696C6C616765722D68617070 +790F77697463682D6861742D6D616769631166697265776F726B732D6578706C6F64650E696E2D +6C6F76652D6865617274731A73696C766572666973682D6D657267652D616E696D6174696F6E15 +677561726469616E2D61747461636B2D736F756E640C6472696E6B2D706F74696F6E0C7468726F +772D706F74696F6E0E7072696D652D746E742D636172740D7072696D652D637265657065720A61 +69722D737570706C791C646570726563617465642D6164642D706C617965722D6C6576656C7317 +677561726469616E2D6D696E696E672D666174696775650F6167656E742D7377696E672D61726D +17647261676F6E2D73746172742D64656174682D616E696D0B67726F756E642D64757374057368 +616B65046665656408626162792D6167650D696E7374616E742D64656174680C6E6F746966792D +74726164650F6C656173682D64657374726F7965640F6361726176616E2D757064617465641174 +616C69736D616E2D616374697661746523646570726563617465642D7570646174652D73747275 +63747572652D6665617475726512706C617965722D737061776E65642D6D6F620470756B651175 +70646174652D737461636B2D73697A650E73746172742D7377696D6D696E670B62616C6C6F6F6E +2D706F700D74726561737572652D68756E740C73756D6D6F6E2D6167656E741666696E69736865 +642D6368617267696E672D6974656D0D6163746F722D67726F772D757012766962726174696F6E +2D64657465637465640A6472696E6B2D6D696C6B127368616B652D7765746E6573732D73746F70 +146B696E657469632D64616D6167652D6465616C741D687572742D776974686F75742D72656365 +6976696E672D64616D61676504000E6163746F722D6576656E742D6964030002016F0375757501 +6B04017204117461726765742D72756E74696D652D696478086576656E742D6964030464617461 +7A10666972652D61742D706F736974696F6E0504000D732D6163746F722D6576656E7403000601 +6D05096E6F2D616374696F6E097377696E672D61726D0777616B652D75700C637269746963616C +2D686974126D616769632D637269746963616C2D68697404000E616E696D6174652D616374696F +6E030008016D09046E6F6E65056275696C64046D696E6508696E7465726163740661747461636B +087573652D6974656D0A7468726F772D6974656D0964726F702D6974656D056576656E74040012 +6163746F722D7377696E672D736F7572636503000A016B0B01720406616374696F6E0917746172 +6765742D6163746F722D72756E74696D652D6964780464617461760C7377696E672D736F757263 +650C040009732D616E696D61746503000D016F037A7A7A01720308706F736974696F6E0F097769 +74682D646174617F096D61782D736C6F74737D040014732D626C6F636B2D7069636B2D72657175 +6573740300100170780172020B6D6973732D686173686573120A6869742D686173686573120400 +1A732D636C69656E742D63616368652D626C6F622D7374617475730300130172011269732D6361 +6368652D737570706F727465647F040015732D636C69656E742D63616368652D73746174757303 +001501720406722D74797065730475756964010A726571756573742D69647309706C617965722D +696478040013636F6D6D616E642D6F726967696E2D6461746103001701720407636F6D6D616E64 +73066F726967696E180B69732D696E7465726E616C7F0776657273696F6E73040011732D636F6D +6D616E642D726571756573740300190172030C636F6E7461696E65722D69647D0E636F6E746169 +6E65722D747970657D167365727665722D696E697469617465642D636C6F73657F040011732D63 +6F6E7461696E65722D636C6F736503001B017206106163746F722D72756E74696D652D69647808 +656D6F74652D69647312656D6F74652D6C656E6774682D7469636B737A0478756964730B706C61 +74666F726D2D69647305666C6167737D040007732D656D6F746503001D0170010172020A72756E +74696D652D6964780F656D6F74652D70696563652D6964731F04000C732D656D6F74652D6C6973 +74030020016D0507696E76616C69640B73746F702D726964696E670F696E7465726163742D7570 +64617465086E70632D6F70656E0E6F70656E2D696E76656E746F7279040006616374696F6E0300 +2201720306616374696F6E23117461726765742D72756E74696D652D69647808706F736974696F +6E0504000A732D696E74657261637403002401710509636F6E7461696E6572000005776F726C64 +0000086372656174697665000004746F646F000007756E6B6E6F776E017A00040017696E76656E +746F72792D616374696F6E2D736F7572636503002601707D0172020C636F6E7461696E65722D69 +647D05736C6F7473280400146C65676163792D7365742D6974656D2D736C6F74030029016B7301 +72050A6964656E7469666965722B0E6D657461646174612D76616C75657A05636F756E747A1062 +6C6F636B2D72756E74696D652D69647A0A65787472612D6461746128040012737461636B2D7265 +71756573742D6974656D03002C0172010C726573756C742D696E6465787D0400206974656D2D73 +7461636B2D726571756573742D616374696F6E2D63726561746503002E017202117072696D6172 +792D6566666563742D69647A137365636F6E646172792D6566666563742D69647A040028697465 +6D2D737461636B2D726571756573742D616374696F6E2D626561636F6E2D7061796D656E740300 +300172030B686F746261722D736C6F747A147072656469637465642D6475726162696C6974797A +08737461636B2D69647A0400246974656D2D737461636B2D726571756573742D616374696F6E2D +6D696E652D626C6F636B030032017202097265636970652D69647A0B72657065746974696F6E73 +7D0400266974656D2D737461636B2D726571756573742D616374696F6E2D63726166742D726563 +697065030034017202097265636970652D69647A0B72657065746974696F6E737D04002B697465 +6D2D737461636B2D726571756573742D616374696F6E2D63726166742D7265636970652D617574 +6F0300360172021063726561746976652D6974656D2D69647A0B72657065746974696F6E737D04 +00286974656D2D737461636B2D726571756573742D616374696F6E2D63726166742D6372656174 +697665030038017202097265636970652D69647A1366696C7465722D737472696E672D696E6465 +787A0400226974656D2D737461636B2D726571756573742D616374696F6E2D6F7074696F6E616C +03003A017203097265636970652D69647A0B7265706169722D636F73747A0B7265706574697469 +6F6E737D0400246974656D2D737461636B2D726571756573742D616374696F6E2D6772696E6473 +746F6E6503003C0172020A7061747465726E2D6964730B72657065746974696F6E737D04001E69 +74656D2D737461636B2D726571756573742D616374696F6E2D6C6F6F6D03003E01702D0172020C +726573756C742D6974656D73C0000D74696D65732D637261667465647D0400326974656D2D7374 +61636B2D726571756573742D616374696F6E2D63726166742D726573756C74732D646570726563 +61746564030041016D021473746172742D6C6F6164696E672D73637265656E12656E642D6C6F61 +64696E672D73637265656E04001A6C6F6164696E672D73637265656E2D7061636B65742D747970 +65030043016B7A0172021A6C6F6164696E672D73637265656E2D7061636B65742D74797065C400 +116C6F6164696E672D73637265656E2D6964C500040010732D6C6F6164696E672D73637265656E +0300460172031070726F746F636F6C2D76657273696F6E7A036A777428097261772D746F6B656E +28040007732D6C6F67696E030048017206066672616D65737505696D616765730C696D6167652D +6865696768747A0B696D6167652D77696474687A0E616E696D6174696F6E2D747970657A14616E +696D6174696F6E2D65787072657373696F6E7A04000E736B696E2D616E696D6174696F6E03004A +0172050A69732D64656661756C747F077061636B2D6964730870696563652D6964730A70696563 +652D74797065730A70726F647563742D69647304000D706572736F6E612D706965636503004C01 +707301720207636F6C6F757273CE000A70696563652D7479706573040019706572736F6E612D70 +696563652D74696E742D636F6C6F757203004F0170CB000170CD000170D00001722F10636C6965 +6E742D72616E646F6D2D696478096465766963652D6F737A096465766963652D6964730C67616D +652D76657273696F6E730D6C616E67756167652D636F6465731263757272656E742D696E707574 +2D6D6F64657A1264656661756C742D696E7075742D6D6F64657A0A75692D70726F66696C657A0E +7365727665722D61646472657373730C6465766963652D6D6F64656C73096775692D7363616C65 +7A18636C69656E742D69732D656469746F722D63617061626C657F1F636C69656E742D65646974 +6F722D636F6E6E656374696F6E2D696E74656E747A116D61782D766965772D64697374616E6365 +7A0B6D656D6F72792D746965727A0D706C6174666F726D2D747970657A0D67726170686963732D +6D6F64657A25636F6D70617469626C652D776974682D636C69656E742D736964652D6368756E6B +2D67656E7F13706C6174666F726D2D6F66666C696E652D69647312706C6174666F726D2D6F6E6C +696E652D69647310706C6174666F726D2D757365722D6964730E73656C662D7369676E65642D69 +64730B706C61792D6661622D6964731074686972642D70617274792D6E616D6573157468697264 +2D70617274792D6E616D652D6F6E6C797F07736B696E2D69647309736B696E2D64617461731173 +6B696E2D696D6167652D6865696768747A10736B696E2D696D6167652D77696474687A0B736B69 +6E2D636F6C6F7572730861726D2D73697A65730C706572736F6E612D736B696E7F0C7072656D69 +756D2D736B696E7F0C747275737465642D736B696E7F0D6F766572726964652D736B696E7F0963 +6170652D646174617307636170652D69647311636170652D696D6167652D6865696768747A1063 +6170652D696D6167652D77696474687A14636170652D6F6E2D636C61737369632D736B696E7F0D +736B696E2D67656F6D657472797315736B696E2D67656F6D657472792D76657273696F6E731373 +6B696E2D7265736F757263652D70617463687313616E696D617465642D696D6167652D64617461 +D10013736B696E2D616E696D6174696F6E2D64617461730E706572736F6E612D706965636573D2 +001270696563652D74696E742D636F6C6F757273D30004000B636C69656E742D64617461030054 +016B7D01720307666F726D2D69647A0D6A736F6E2D726573706F6E73652B12666F726D2D63616E +63656C2D726561736F6ED600040015732D6D6F64616C2D666F726D2D726573706F6E7365030057 +0172040E76696F6C6174696F6E2D747970657A1276696F6C6174696F6E2D73657665726974797A +1376696F6C6174696F6E2D7061636B65742D69647A1176696F6C6174696F6E2D636F6E74657874 +7304001A732D7061636B65742D76696F6C6174696F6E2D7761726E696E67030059016D2907756E +6B6E6F776E1373746172742D64657374726F792D626C6F636B1361626F72742D64657374726F79 +2D626C6F636B1273746F702D64657374726F792D626C6F636B116765742D757064617465642D62 +6C6F636B0964726F702D6974656D0E73746172742D736C656570696E670D73746F702D736C6565 +70696E67077265737061776E0A73746172742D6A756D700F73746172742D737072696E74696E67 +0E73746F702D737072696E74696E670E73746172742D736E65616B696E670D73746F702D736E65 +616B696E671663726561746976652D64657374726F792D626C6F636B146368616E67652D64696D +656E73696F6E2D61636B0D73746172742D676C6964696E670C73746F702D676C6964696E671264 +656E792D64657374726F792D626C6F636B0B637261636B2D626C6F636B0B6368616E67652D736B +696E17757064617465642D656E6368616E74696E672D736565640E73746172742D7377696D6D69 +6E670D73746F702D7377696D6D696E671173746172742D7370696E2D61747461636B1073746F70 +2D7370696E2D61747461636B13696E7465726163742D776974682D626C6F636B15707265646963 +742D64657374726F792D626C6F636B16636F6E74696E75652D64657374726F792D626C6F636B11 +73746172742D6974656D2D7573652D6F6E1073746F702D6974656D2D7573652D6F6E1068616E64 +6C65642D74656C65706F72740C6D69737365642D7377696E670E73746172742D637261776C696E +670D73746F702D637261776C696E670C73746172742D666C79696E670B73746F702D666C79696E +6716636C69656E742D61636B2D7365727665722D646174611073746172742D7573696E672D6974 +656D0F696E7465726E616C2D75706461746505636F756E74040012706C617965722D616374696F +6E2D7479706503005B01720511706C617965722D72756E74696D652D69647806616374696F6EDC +000E626C6F636B2D706F736974696F6E0F0A726573756C742D706F730F04666163657A04000F73 +2D706C617965722D616374696F6E03005D01720306616374696F6E7A09626C6F636B2D706F730F +04666163657A040013706C617965722D626C6F636B2D616374696F6E03005F016D04056D6F7573 +6505746F7563680867616D652D706164116D6F74696F6E2D636F6E74726F6C6C657204000A696E +7075742D6D6F6465030061016D05066E6F726D616C067465617365720673637265656E0A657869 +742D6C6576656C096E756D2D6D6F646573040009706C61792D6D6F6465030063016D0305746F75 +63680963726F73736861697207636C6173736963040011696E746572616374696F6E2D6D6F6465 +6C030065016D4206617363656E640764657363656E640A6E6F7274682D6A756D70096A756D702D +646F776E0B737072696E742D646F776E0D6368616E67652D686569676874076A756D70696E6715 +6175746F2D6A756D70696E672D696E2D776174657208736E65616B696E670A736E65616B2D646F +776E02757004646F776E046C6566740572696768740775702D6C6566740875702D726967687407 +77616E742D75700977616E742D646F776E0E77616E742D646F776E2D736C6F770C77616E742D75 +702D736C6F7709737072696E74696E670C617363656E642D626C6F636B0D64657363656E642D62 +6C6F636B11736E65616B2D746F67676C652D646F776E0D706572736973742D736E65616B0F7374 +6172742D737072696E74696E670E73746F702D737072696E74696E670E73746172742D736E6561 +6B696E670D73746F702D736E65616B696E670E73746172742D7377696D6D696E670D73746F702D +7377696D6D696E670D73746172742D6A756D70696E670D73746172742D676C6964696E670C7374 +6F702D676C6964696E6718706572666F726D2D6974656D2D696E746572616374696F6E15706572 +666F726D2D626C6F636B2D616374696F6E731A706572666F726D2D6974656D2D737461636B2D72 +6571756573741068616E646C65642D74656C65706F727407656D6F74696E670C6D69737365642D +7377696E670E73746172742D637261776C696E670D73746F702D637261776C696E670C73746172 +742D666C79696E670B73746F702D666C79696E6716636C69656E742D61636B2D7365727665722D +6461746118636C69656E742D7072656469637465642D76656869636C650D706164646C696E672D +6C6566740E706164646C696E672D72696768741C626C6F636B2D627265616B696E672D64656C61 +792D656E61626C656414686F72697A6F6E74616C2D636F6C6C6973696F6E12766572746963616C +2D636F6C6C6973696F6E09646F776E2D6C6566740A646F776E2D72696768741073746172742D75 +73696E672D6974656D2063616D6572612D72656C61746976652D6D6F76656D656E742D656E6162 +6C656420726F742D636F6E74726F6C6C65642D62792D6D6F76652D646972656374696F6E117374 +6172742D7370696E2D61747461636B1073746F702D7370696E2D61747461636B1469732D686F74 +6261722D746F7563682D6F6E6C79116A756D702D72656C65617365642D726177106A756D702D70 +7265737365642D726177106A756D702D63757272656E742D72617712736E65616B2D72656C6561 +7365642D72617711736E65616B2D707265737365642D72617711736E65616B2D63757272656E74 +2D7261770F696E7465726E616C2D75706461746504000A696E7075742D64617461030067017203 +0D73656C65637465642D736C6F747A0C636F6E7461696E65722D69647D1273686F756C642D7365 +6C6563742D736C6F747F04000F732D706C617965722D686F7462617203006901710204626F6F6C +017F0005666C6F617401760004000D6162696C6974792D76616C756503006B017202076162696C +6974797A0576616C7565EC00040011732D726571756573742D6162696C69747903006D0172020C +6368756E6B2D7261646975737A106D61782D6368756E6B2D7261646975737D040016732D726571 +756573742D6368756E6B2D72616469757303006F01720116636C69656E742D6E6574776F726B2D +76657273696F6E7A04001A732D726571756573742D6E6574776F726B2D73657474696E67730300 +7101720308726573706F6E73657D0D646F776E6C6F61642D73697A657A087061636B2D696473CE +0004001F732D7265736F757263652D7061636B2D636C69656E742D726573706F6E736503007301 +6D0313736561726368696E672D666F722D737061776E0E72656164792D746F2D737061776E1563 +6C69656E742D72656164792D746F2D737061776E04000D7265737061776E2D7374617465030075 +01720308706F736974696F6E04057374617465F60011706C617965722D72756E74696D652D6964 +78040009732D7265737061776E03007701720109706C617965722D696478040021732D7365742D +6C6F63616C2D706C617965722D61732D696E697469616C697A6564030079017205126C6566742D +696E76656E746F72792D7461627A1372696768742D696E76656E746F72792D7461627A0966696C +746572696E677F0A6C61796F75742D696E767A0C6C61796F75742D63726166747A04001E732D73 +65742D706C617965722D696E76656E746F72792D6F7074696F6E7303007B016D0C037261770463 +6861740B7472616E736C6174696F6E05706F7075700D6A756B65626F782D706F70757003746970 +0673797374656D07776869737065720C616E6E6F756E63656D656E740C6A736F6E2D7768697370 +6572046A736F6E116A736F6E2D616E6E6F756E63656D656E74040010746578742D7061636B6574 +2D7479706503007D017208116E656564732D7472616E736C6174696F6E7F06722D74797065FE00 +0B736F757263652D6E616D6573076D657373616765730A706172616D6574657273CE0004787569 +647310706C6174666F726D2D636861742D6964731066696C74657265642D6D6573736167652B04 +0006732D7465787403007F0172040E6174747269627574652D6E616D6573096D696E2D76616C75 +65760D63757272656E742D76616C756576096D61782D76616C75657604001073796E6365642D61 +74747269627574650300810101707A017202046E616D65730676616C7565738301040009656E75 +6D2D646174610300840101720205696E6465787A0576616C75657A04001F636861696E65642D73 +7562636F6D6D616E642D72656C6174696F6E736869700300860101708701017202046E616D6573 +11737562636F6D6D616E642D76616C7565738801040017636861696E65642D737562636F6D6D61 +6E642D6461746103008901017204046E616D65730C70617273652D73796D626F6C7A0B69732D6F +7074696F6E616C7F076F7074696F6E737D04000A706172616D2D6461746103008B0101708C0101 +72020B69732D636861696E696E677F0E706172616D657465722D646174618D0104000D6F766572 +6C6F61642D6461746103008E0101720209656E756D2D6E616D65730C656E756D2D6F7074696F6E +73CE0004000E736F66742D656E756D2D646174610300900101720311656E756D2D76616C75652D +73796D626F6C7A0B656E756D2D73796D626F6C7A12636F6E73747261696E742D696E6469636573 +28040016636F6E73747261696E65642D76616C75652D64617461030092010172020E626C6F636B +2D706F736974696F6E0F0F6163746F722D646174612D7461677373040012632D626C6F636B2D61 +63746F722D64617461030094010172030E626C6F636B2D706F736974696F6E0F0A6576656E742D +747970657A0B6576656E742D76616C75657A04000D632D626C6F636B2D6576656E740300960101 +72080E626F73732D656E746974792D69647810706C617965722D656E746974792D6964780A6576 +656E742D747970657D057469746C65730E66696C74657265642D7469746C6573116865616C7468 +2D70657263656E746167657605636F6C6F727D076F7665726C61797D04000C632D626F73732D65 +76656E74030098010172040C64696D656E73696F6E2D69647A08706F736974696F6E0407726573 +7061776E7F116C6F6164696E672D73637265656E2D6964C500040012632D6368616E67652D6469 +6D656E73696F6E03009A010172010C6368756E6B2D7261646975737A040016632D6368756E6B2D +7261646975732D7570646174656403009C0101720207626C6F622D69647809626C6F622D646174 +61280400116D697373696E672D626C6F622D6461746103009E0101709F010172010D6D69737369 +6E672D626C6F6273A00104001C632D636C69656E742D63616368652D6D6973732D726573706F6E +73650300A101016D0F07756E6B6E6F776E06676F6F676C6503696F73036F737806616D617A6F6E +07676561722D7672037577700577696E3332096465646963617465640574762D6F7304736F6E79 +026E780478626F780D77696E646F77732D70686F6E65056C696E757804000E6275696C642D706C +6174666F726D0300A301016D0607756E6B6E6F776E08737572766976616C086372656174697665 +09616476656E747572650764656661756C7409737065637461746F7204000967616D652D747970 +650300A501016D040776697369746F72066D656D626572086F70657261746F7206637573746F6D +040017706C617965722D7065726D697373696F6E2D6C6576656C0300A701016D0603616E790E67 +616D652D6469726563746F72730561646D696E04686F7374056F776E657208696E7465726E616C +040018636F6D6D616E642D7065726D697373696F6E2D6C6576656C0300A90101708F0101720704 +6E616D65730B6465736372697074696F6E7305666C6167737A107065726D697373696F6E2D6C65 +76656CAA010A616C6961732D656E756D7A27636F6D6D616E642D646174612D636861696E65642D +737562636F6D6D616E642D696E64657865738301096F7665726C6F616473AB0104000C636F6D6D +616E642D646174610300AC010170850101708A010170AD0101709101017093010172080B656E75 +6D2D76616C756573CE0019636861696E65642D737562636F6D6D616E642D76616C756573CE000A +706F73742D6669786573CE0009656E756D2D64617461AE0117636861696E65642D737562636F6D +6D616E642D64617461AF0108636F6D6D616E6473B0010A736F66742D656E756D73B1010B636F6E +73747261696E7473B201040014632D617661696C61626C652D636F6D6D616E64730300B3010172 +061073657269616C697A65642D6C617965727A0D6162696C69746965732D7365747A0D6162696C +6974792D76616C75657A09666C792D73706565647612766572746963616C2D666C792D73706565 +64760A77616C6B2D73706565647604002A73657269616C697A65642D6162696C69746965732D64 +6174612D73657269616C697A65642D6C617965720300B5010170B601017204147461726765742D +706C617965722D7261772D69647812706C617965722D7065726D697373696F6E73A80113636F6D +6D616E642D7065726D697373696F6E73AA01066C6179657273B70104001973657269616C697A65 +642D6162696C69746965732D646174610300B8010172061072696464656E2D756E697175652D69 +64780F72696465722D756E697175652D696478096C696E6B2D747970657D09696D6D6564696174 +657F0F72696465722D696E697469617465647F1876656869636C652D616E67756C61722D76656C +6F636974797604000A6163746F722D6C696E6B0300BA010172040C636F6E7461696E65722D6964 +7D0E636F6E7461696E65722D747970657D08706F736974696F6E0F107461726765742D656E7469 +74792D696478040010632D636F6E7461696E65722D6F70656E0300BC01016F027575016B760172 +070F70726564696374696F6E2D747970657D03706F730409706F732D64656C74610408726F7461 +74696F6EBE011876656869636C652D616E67756C61722D76656C6F63697479BF01096F6E2D6772 +6F756E647F047469636B78040020632D636F72726563742D706C617965722D6D6F76652D707265 +64696374696F6E0300C0010172030F6974656D2D6964656E746966696572730E6D657461646174 +612D76616C75657A05636F756E747A0400156974656D2D64657363726970746F722D636F756E74 +0300C20101720107636F6E746578747A0400197265636970652D756E6C6F636B2D726571756972 +656D656E740300C401016D0703616C6C0C636F6E737472756374696F6E066E6174757265096571 +7569706D656E74056974656D73116974656D2D636F6D6D616E642D6F6E6C7909756E646566696E +656404001163726561746976652D63617465676F72790300C60101720406726561736F6E7A0C73 +6B69702D6D6573736167657F076D657373616765731066696C74657265642D6D65737361676573 +04000C632D646973636F6E6E6563740300C801016D01046E756C6C04000A72756C652D76616C75 +650300CA010172030972756C652D6E616D65731472756C652D63616E2D62652D6D6F6469666965 +647F0A72756C652D76616C7565CB0104000967616D652D72756C650300CC010170CD0101720109 +72756C652D64617461CE01040013632D67616D6572756C65732D6368616E6765640300CF010172 +05096974656D2D6E616D6573076974656D2D69647A1269732D636F6D706F6E656E742D62617365 +647F0C6974656D2D76657273696F6E7A0E636F6D706F6E656E742D64617461280400096974656D +2D646174610300D1010170D201017201056974656D73D30104000F632D6974656D2D7265676973 +7472790300D4010172070E7265717565737465642D736C6F747D04736C6F747D06616D6F756E74 +7D116974656D2D737461636B2D6E65742D69647A0B637573746F6D2D6E616D65731466696C7465 +7265642D637573746F6D2D6E616D6573156475726162696C6974792D636F7272656374696F6E7A +04001D6974656D2D737461636B2D726573706F6E73652D736C6F742D696E666F0300D601017204 +0964696D656E73696F6E7A0D63616368652D656E61626C65647F056368756E6B280C626C6F636B +2D6163746F7273CE0004000D632D6C6576656C2D6368756E6B0300D801017203086576656E742D +69647A08706F736974696F6E0404646174617A04000D632D6C6576656C2D6576656E740300DA01 +016D04177061727469636C65732D64657374726F792D626C6F636B11626C6F636B2D7374617274 +2D627265616B10626C6F636B2D73746F702D627265616B12626C6F636B2D7570646174652D6272 +65616B04000B6C6576656C2D6576656E740300DC010172080B736F756E642D6576656E74730870 +6F736974696F6E0404646174617A106163746F722D6964656E746966696572730769732D626162 +797F0969732D676C6F62616C7F0F6163746F722D756E697175652D69647810666972652D61742D +706F736974696F6E05040013632D6C6576656C2D736F756E642D6576656E740300DE0101720811 +7461726765742D72756E74696D652D696478086576656E742D69647D096566666563742D69647A +106566666563742D616D706C69666965727A0E73686F772D7061727469636C65737F1565666665 +63742D6475726174696F6E2D7469636B737A047469636B7807616D6269656E747F04000C632D6D +6F622D6566666563740300E00101720207666F726D2D69647A0C666F726D2D75692D6A736F6E73 +040014632D6D6F64616C2D666F726D2D726571756573740300E201017206106163746F722D7275 +6E74696D652D696478066865616465727D08706F736974696F6E040A726F746174696F6E2D787D +0A726F746174696F6E2D797D0F726F746174696F6E2D792D686561647D040015632D6D6F76652D +6163746F722D6162736F6C7574650300E40101720811656E746974792D72756E74696D652D6964 +7805666C6167737A017876017976017A760570697463687D037961777D08686561642D7961777D +040012632D6D6F76652D6163746F722D64656C74610300E60101720B11706C617965722D72756E +74696D652D69647808706F736974696F6E0405706974636876037961777608686561642D796177 +76046D6F64657D096F6E2D67726F756E647F11726964696E672D72756E74696D652D6964780E74 +656C65706F72742D63617573657A1B74656C65706F72742D736F757263652D656E746974792D74 +7970657A047469636B7804000D632D6D6F76652D706C617965720300E8010170BE010172030C70 +6F732D666F722D766965770F0A6E65772D7261646975737A177365727665722D6275696C642D63 +68756E6B2D6C697374EA01040020632D6E6574776F726B2D6368756E6B2D7075626C6973686572 +2D7570646174650300EB0101720515636F6D7072657373696F6E2D7468726573686F6C647A1563 +6F6D7072657373696F6E2D616C676F726974686D7A17636C69656E742D7468726F74746C652D65 +6E61626C65647F19636C69656E742D7468726F74746C652D7468726573686F6C647D16636C6965 +6E742D7468726F74746C652D7363616C617276040012632D6E6574776F726B2D73657474696E67 +730300ED01016D0A0D6C6F67696E2D737563636573730F6F757464617465642D636C69656E740F +6F757464617465642D7365727665720C706C617965722D737061776E0E696E76616C69642D7465 +6E616E741F65646974696F6E2D6D69736D617463682D6564752D746F2D76616E696C6C611F6564 +6974696F6E2D6D69736D617463682D76616E696C6C612D746F2D656475167365727665722D6675 +6C6C2D7375622D636C69656E7421656469746F722D6D69736D617463682D656469746F722D746F +2D76616E696C6C6121656469746F722D6D69736D617463682D76616E696C6C612D746F2D656469 +746F7204000D632D706C61792D7374617475730300EF010172030D73656C65637465642D736C6F +747A0C636F6E7461696E65722D69647D1273686F756C642D73656C6563742D736C6F747F04000F +632D706C617965722D686F746261720300F1010172020A70696563652D747970657306636F6C6F +7273830104001070696563652D74696E742D636F6C6F720300F3010170F40101721A07736B696E +2D6964730B706C61792D6661622D6964730E7265736F757263652D7061746368280B696D616765 +2D77696474687A0C696D6167652D6865696768747A09736B696E2D64617461280A616E696D6174 +696F6E73D1000A636170652D77696474687A0B636170652D6865696768747A09636170652D6461 +7461280D67656F6D657472792D64617461280E616E696D6174696F6E2D64617461281C67656F6D +657472792D646174612D656E67696E652D76657273696F6E2807636170652D6964730766756C6C +2D6964730861726D2D73697A65730A736B696E2D636F6C6F72730E706572736F6E612D70696563 +6573D2001170696563652D74696E742D636F6C6F7273F5010A69732D7072656D69756D7F0A6973 +2D706572736F6E617F17706572736F6E612D636170652D6F6E2D636C61737369637F0F69732D70 +72696D6172792D757365727F136F766572726964652D617070656172616E63657F0A69732D7472 +75737465647F0C70726F66696C652D6861736873040004736B696E0300F60101720B0475756964 +0110656E746974792D756E697175652D69647808757365726E616D657304787569647310706C61 +74666F726D2D636861742D6964730E6275696C642D706C6174666F726DA40104736B696EF7010A +69732D746561636865727F0769732D686F73747F0D69732D7375622D636C69656E747F0C706C61 +7965722D636F6C6F7228040011706C617965722D6C6973742D656E7472790300F8010170F90101 +720206616374696F6E7D07656E7472696573FA0104000D632D706C617965722D6C6973740300FB +010172010F7461726765742D6163746F722D69647804000E632D72656D6F76652D6163746F7203 +00FD010172010E6F626A6563746976652D6E616D6573040012632D72656D6F76652D6F626A6563 +746976650300FF01017203077061636B2D6964730776657273696F6E730D7375622D7061636B2D +6E616D65730400107061636B2D696E7374616E63652D696403008102017202097061636B2D7575 +6964010C7061636B2D76657273696F6E7304000F7061636B2D69642D76657273696F6E03008302 +0172090F7061636B2D69642D76657273696F6E8402097061636B2D73697A65780B636F6E74656E +742D6B6579730C7375627061636B2D6E616D657310636F6E74656E742D6964656E74697479730B +6861732D736372697074737F0D69732D6164646F6E2D7061636B7F1669732D7261792D74726163 +696E672D63617061626C657F0763646E2D75726C7304000E7061636B2D696E666F2D6461746103 +00850201708602017206167265736F757263652D7061636B2D72657175697265647F0F6861732D +6164646F6E2D7061636B737F0B6861732D736372697074737F1D666F7263652D64697361626C65 +2D76696272616E742D76697375616C737F1D776F726C642D74656D706C6174652D69642D616E64 +2D76657273696F6E84020E7265736F757263652D7061636B738702040015632D7265736F757263 +652D7061636B732D696E666F030088020171090462797465017D000573686F7274017A0003696E +74017A0005666C6F617401760006737472696E670173000C636F6D706F756E642D746167000008 +6974656D2D706F73010F0005696E743634017800047665633301040004000E6D65746164617461 +2D76616C756503008A02016F027A7A01708C02016F027A7601708E0201720210696E742D656E74 +726965732D6C6973748D0212666C6F61742D656E74726965732D6C6973748F0204001270726F70 +657274792D73796E632D6461746103009002017082010170BB0101720C0F7461726765742D6163 +746F722D696478117461726765742D72756E74696D652D6964780A6163746F722D747970657308 +706F736974696F6E040876656C6F636974790408726F746174696F6EBE010F792D686561642D72 +6F746174696F6E760F792D626F64792D726F746174696F6E760F617474726962757465732D6C69 +737492020A6163746F722D64617461731173796E6365642D70726F7065727469657391020B6163 +746F722D6C696E6B73930204000B632D6164642D6163746F720300940201720411746172676574 +2D72756E74696D652D6964780A6163746F722D64617461731173796E6365642D70726F70657274 +6965739102047469636B78040010632D7365742D6163746F722D6461746103009602017201046C +696E6BBB01040010632D7365742D6163746F722D6C696E6B03009802017203117461726765742D +72756E74696D652D696478066D6F74696F6E04047469636B78040012632D7365742D6163746F72 +2D6D6F74696F6E03009A020172010A646966666963756C74797A040010632D7365742D64696666 +6963756C747903009C0201720511646973706C61792D736C6F742D6E616D65730E6F626A656374 +6976652D6E616D6573166F626A6563746976652D646973706C61792D6E616D65730D6372697465 +7269612D6E616D65730A736F72742D6F726465727A040017632D7365742D646973706C61792D6F +626A65637469766503009E02017201066865616C74687A04000C632D7365742D6865616C746803 +00A00201720110706C617965722D67616D652D74797065A601040016632D7365742D706C617965 +722D67616D652D747970650300A2020172060D73636F7265626F6172642D6964780E6F626A6563 +746976652D6E616D65730573636F72657A0A656E7472792D747970657A10656E746974792D756E +697175652D6964780B637573746F6D2D6E616D657304000B73636F72652D656E7472790300A402 +0170A50201720206616374696F6E7A07656E7472696573A60204000B632D7365742D73636F7265 +0300A702016D020E706C617965722D7265737061776E0D776F726C642D7265737061776E040013 +737061776E2D706F736974696F6E2D747970650300A90201720413737061776E2D706F73697469 +6F6E2D74797065AA020E626C6F636B2D706F736974696F6E0F0E64696D656E73696F6E2D747970 +657A0F737061776E2D626C6F636B2D706F730F040014632D7365742D737061776E2D706F736974 +696F6E0300AB020172010474696D657A04000A632D7365742D74696D650300AD02016D0905636C +656172057265736574057469746C65087375627469746C6509616374696F6E6261720574696D65 +73117469746C652D746578742D6F626A656374147375627469746C652D746578742D6F626A6563 +7415616374696F6E6261722D746578742D6F626A65637404000A7469746C652D747970650300AF +020172080A7469746C652D74797065B0020A7469746C652D74657874730C666164652D696E2D74 +696D657A09737461792D74696D657A0D666164652D6F75742D74696D657A04787569647312706C +6174666F726D2D6F6E6C696E652D6964731666696C74657265642D7469746C652D6D6573736167 +657304000B632D7365742D7469746C650300B10201720211706C617965722D72756E74696D652D +6964780D637265646974732D73746174657A04000E632D73686F772D637265646974730300B302 +0172080D657870657269656E63652D6964010F657870657269656E63652D6E616D657313657870 +657269656E63652D776F726C642D69640115657870657269656E63652D776F726C642D6E616D65 +730A63726561746F722D6964730E756E6B6E6F776E2D757569642D31010E756E6B6E6F776E2D75 +7569642D3201097365727665722D696473040013676174686572696E672D6A6F696E2D696E666F +0300B5020172020873746F72652D6964730A73746F72652D6E616D657304001673746F72652D65 +6E7472792D706F696E742D696E666F0300B7020172020F657870657269656E63652D6E616D6573 +0A776F726C642D6E616D657304000D70726573656E63652D696E666F0300B902016BB602016BB8 +02016BBA0201720309676174686572696E67BB021173746F72652D656E7472792D706F696E74BC +020870726573656E6365BD020400177365727665722D6A6F696E2D696E666F726D6174696F6E03 +00BE02017204097365727665722D6964730B7363656E6172696F2D69647308776F726C642D6964 +73086F776E65722D6964730400157365727665722D74656C656D657472792D646174610300C002 +017202046E616D657307656E61626C65647F0400116578706572696D656E742D746F67676C6503 +00C2020170C30201720207746F67676C6573C402186578706572696D656E74732D657665722D74 +6F67676C65647F04000B6578706572696D656E74730300C5020170820201720515746578747572 +652D7061636B2D72657175697265647F11746578747572652D7061636B2D6C697374C702116261 +73652D67616D652D76657273696F6E730B6578706572696D656E7473C60214696E636C7564652D +656469746F722D7061636B737F04001C632D7265736F757263652D7061636B2D737461636B2D70 +61636B65740300C802016D050D6E6F2D6D756C74692D706C61790B696E766974652D6F6E6C790C +667269656E64732D6F6E6C7912667269656E64732D6F662D667269656E6473067075626C696304 +001467616D652D7075626C6973682D73657474696E670300CA0201723504736565647810737061 +776E2D62696F6D652D747970657A11637573746F6D2D62696F6D652D6E616D65730964696D656E +73696F6E7A0E67656E657261746F722D747970657A0E776F726C642D67616D656D6F6465A60108 +68617264636F72657F0A646966666963756C74797A0E737061776E2D706F736974696F6E0F1968 +61732D616368696576656D656E74732D64697361626C65647F11656469746F722D776F726C642D +747970657A1469732D637265617465642D696E2D656469746F727F1769732D6578706F72746564 +2D66726F6D2D656469746F727F136461792D6379636C652D73746F702D74696D657A1765647563 +6174696F6E2D65646974696F6E2D6F666665727A1E6861732D656475636174696F6E2D66656174 +757265732D656E61626C65647F14656475636174696F6E2D70726F647563742D6964730A726169 +6E2D6C6576656C760F6C696768746E696E672D6C6576656C76256861732D636F6E6669726D6564 +2D706C6174666F726D2D6C6F636B65642D636F6E74656E747F187761732D6D756C7469706C6179 +65722D696E74656E6465647F1D7761732D6C616E2D62726F616463617374696E672D696E74656E +6465647F1B78626F782D6C6976652D62726F6164636173742D73657474696E67CB021A706C6174 +666F726D2D62726F6164636173742D73657474696E67CB0210636F6D6D616E64732D656E61626C +65647F1969732D746578747572652D7061636B732D72657175697265647F0972756C652D646174 +61CE010B6578706572696D656E7473C6020B626F6E75732D63686573747F1A6861732D73746172 +742D776974682D6D61702D656E61626C65647F107065726D697373696F6E2D6C6576656C7D1A73 +65727665722D73696D756C6174696F6E2D64697374616E63657A186861732D6C6F636B65642D62 +65686176696F722D7061636B7F186861732D6C6F636B65642D7265736F757263652D7061636B7F +1D69732D66726F6D2D6C6F636B65642D776F726C642D74656D706C6174657F1B69732D7573696E +672D6D73612D67616D6572746167732D6F6E6C797F1669732D66726F6D2D776F726C642D74656D +706C6174657F1F69732D776F726C642D74656D706C6174652D6F7074696F6E2D6C6F636B65647F +1D69732D6F6E6C792D737061776E696E672D76312D76696C6C61676572737F1569732D64697361 +626C696E672D706572736F6E61737F1969732D64697361626C696E672D637573746F6D2D736B69 +6E737F10656D6F74652D636861742D6D757465647F0C67616D652D76657273696F6E73136C696D +697465642D776F726C642D77696474687A146C696D697465642D776F726C642D6865696768747A +0A6E65772D6E65746865727F1A6564752D7368617265642D7572692D627574746F6E2D6E616D65 +73176564752D7368617265642D7572692D6C696E6B2D757269732E6F766572726964652D666F72 +63652D6578706572696D656E74616C2D67616D65706C61792D6861732D76616C75657F16636861 +742D7265737472696374696F6E2D6C6576656C7D1B64697361626C652D706C617965722D696E74 +6572616374696F6E737F1F7365727665722D656469746F722D636F6E6E656374696F6E2D706F6C +6963797A2C616C6C6F772D616E6F6E796D6F75732D626C6F636B2D64726F70732D696E2D656469 +746F722D776F726C64737F04000E6C6576656C2D73657474696E67730300CC02016BBF0201721D +09656E746974792D6964781172756E74696D652D656E746974792D6964780F706C617965722D67 +616D656D6F6465A60108706F736974696F6E040570697463687603796177760E6C6576656C2D73 +657474696E6773CD02086C6576656C2D6964730A6C6576656C2D6E616D6573197072656D69756D +2D776F726C642D74656D706C6174652D6964730869732D747269616C7F13726577696E642D6869 +73746F72792D73697A657A237365727665722D617574686F72697461746976652D626C6F636B2D +627265616B696E677F1263757272656E742D6C6576656C2D74696D657810656E6368616E746D65 +6E742D736565647A15626C6F636B2D70726F706572746965732D73697A657A1A6D756C7469706C +617965722D636F7272656C6174696F6E2D6964731C656E61626C652D6974656D737461636B2D6E +65742D6D616E616765727F0E7365727665722D76657273696F6E730B636F6D706F756E642D6964 +7D0C636F6D706F756E642D6C656E7A0C636F6D706F756E642D656E647D17626C6F636B2D726567 +69737472792D636865636B73756D7811776F726C642D74656D706C6174652D6964011C656E6162 +6C652D636C69656E74736964652D67656E65726174696F6E7F1B626C6F636B6E6574776F726B2D +6964732D6172652D6861736865647F127365727665722D617574682D736F756E64737F17736572 +7665722D6A6F696E2D696E666F726D6174696F6ECE020974656C656D65747279C10204000C632D +73746172742D67616D650300CF02017204046E616D65730269647D036C656E7A03656E647D0400 +0267670300D1020172020F6974656D2D72756E74696D652D696478106163746F722D72756E7469 +6D652D696478040011632D74616B652D6974656D2D6163746F720300D3020172030E7365727665 +722D61646472657373730B7365727665722D706F72747A0C72656C6F61642D776F726C647F0400 +0A632D7472616E736665720300D5020172010464617461B901040012632D7570646174652D6162 +696C69746965730300D702016D15056275696C64046D696E6512646F6F72732D616E642D737769 +74636865730F6F70656E2D636F6E7461696E6572730E61747461636B2D706C61796572730B6174 +7461636B2D6D6F6273116F70657261746F722D636F6D6D616E64730874656C65706F72740C696E +76756C6E657261626C6506666C79696E67076D61792D666C790A696E7374616275696C64096C69 +6768746E696E6709666C792D73706565640A77616C6B2D7370656564056D757465640D776F726C +642D6275696C646572076E6F2D636C69701270726976696C656765642D6275696C646572127665 +72746963616C2D666C792D73706565640D6162696C6974792D636F756E740400076162696C6974 +790300D90201720602696473046E616D657306616D6F756E7476096F7065726174696F6E7A076F +706572616E647A0F69732D73657269616C697A61626C657F0400126174747269627574652D6D6F +6469666965720300DB020170DC02017208096D696E2D76616C756576096D61782D76616C756576 +0D63757272656E742D76616C7565761164656661756C742D6D696E2D76616C7565761164656661 +756C742D6D61782D76616C7565760D64656661756C742D76616C756576046E616D6573096D6F64 +696669657273DD0204000E6174747269627574652D646174610300DE020170DF02017203117461 +726765742D72756E74696D652D6964780E6174747269627574652D6C697374E002047469636B78 +040013632D7570646174652D617474726962757465730300E1020172040E626C6F636B2D706F73 +6974696F6E0F10626C6F636B2D72756E74696D652D69647A05666C6167737A056C617965727A04 +000E632D7570646174652D626C6F636B0300E30201720A0C636F6E7461696E65722D69647D0672 +2D747970657D0473697A657A0B7472616465722D746965727A10656E746974792D756E69717565 +2D696478136C6173742D74726164696E672D706C61796572780C646973706C61792D6E616D6573 +147573652D6E65772D74726164652D73637265656E7F137573696E672D65636F6E6F6D792D7472 +6164657F04646174617304000E632D7570646174652D74726164650300E5020172080269647A0A +737461636B2D73697A657A096175782D76616C75657A10626C6F636B2D72756E74696D652D6964 +7A086E62742D64617461730F706C6163652D6F6E2D626C6F636B73CE000E64657374726F792D62 +6C6F636B73CE0014736869656C642D626C6F636B696E672D7469636B780400176E6574776F726B +2D6974656D2D64657363726970746F720300E7020172060B736F757263652D747970657A097769 +6E646F772D6964C5000C736F757263652D666C616773C5000E696E76656E746F72792D736C6F74 +7A086F6C642D6974656DE802086E65772D6974656DE802040010696E76656E746F72792D616374 +696F6E0300E90201720B0B616374696F6E2D747970657A0C747269676765722D747970657D0E62 +6C6F636B2D706F736974696F6E0F0A626C6F636B2D666163657D0C686F742D6261722D736C6F74 +7A0C6974656D2D696E2D68616E64E8020F706C617965722D706F736974696F6E040E636C69636B +2D706F736974696F6E0410626C6F636B2D72756E74696D652D69647A11636C69656E742D707265 +64696374696F6E7D15636C69656E742D636F6F6C646F776E2D73746174657D0400197573652D69 +74656D2D7472616E73616374696F6E2D646174610300EB02017206187461726765742D656E7469 +74792D72756E74696D652D6964780B616374696F6E2D747970657A0C686F742D6261722D736C6F +747A0C6974656D2D696E2D68616E64E8020F706C617965722D706F736974696F6E040E636C6963 +6B2D706F736974696F6E040400237573652D6974656D2D6F6E2D656E746974792D7472616E7361 +6374696F6E2D646174610300ED020172040B616374696F6E2D747970657A0C686F742D6261722D +736C6F747A0C6974656D2D696E2D68616E64E8020D686561642D706F736974696F6E0404001D72 +656C656173652D6974656D2D7472616E73616374696F6E2D646174610300EF02017105066E6F72 +6D616C017300086D69736D61746368017300087573652D6974656D01EC0200127573652D697465 +6D2D6F6E2D656E7469747901EE02000C72656C656173652D6974656D01F002000400107472616E +73616374696F6E2D646174610300F10201702A0170EA02017206116C65676163792D7265717565 +73742D69647A156C65676163792D7365742D6974656D2D736C6F7473F302096861732D76616C75 +657F07616374696F6E73F402107472616E73616374696F6E2D747970657A107472616E73616374 +696F6E2D64617461F202040017732D696E76656E746F72792D7472616E73616374696F6E0300F5 +0201720B0B616374696F6E2D747970657A0C747269676765722D747970657D0E626C6F636B2D70 +6F736974696F6E0F0A626C6F636B2D666163657D0C686F742D6261722D736C6F747A0C6974656D +2D696E2D68616E64E8020F706C617965722D706F736974696F6E040E636C69636B2D706F736974 +696F6E0410626C6F636B2D72756E74696D652D69647A11636C69656E742D70726564696374696F +6E7D15636C69656E742D636F6F6C646F776E2D73746174657D040020706C617965722D7573652D +6974656D2D7472616E73616374696F6E2D646174610300F702017204116C65676163792D726571 +756573742D69647A0C6C65676163792D736C6F7473F30207616374696F6E73F4020B7472616E73 +616374696F6EF802040017706C617965722D696E76656E746F72792D616374696F6E0300F90201 +70C3010170E802017208097265636970652D69647305696E707574FB02066F7574707574FC0204 +757569640105626C6F636B73087072696F726974797A12756E6C6F636B2D726571756972656D65 +6E74C501117265636970652D6E6574776F726B2D69647A040018626564726F636B2D7368617065 +6C6573732D7265636970650300FD0201720B097265636970652D6964730577696474687A066865 +696768747A05696E707574FB02066F7574707574FC0204757569640105626C6F636B7308707269 +6F726974797A0F617373756D652D73796D6D657472797F12756E6C6F636B2D726571756972656D +656E74C501117265636970652D6E6574776F726B2D69647A040015626564726F636B2D73686170 +65642D7265636970650300FF020171020973686170656C65737301FE0200067368617065640180 +030004000E626564726F636B2D7265636970650300810301708203017202077265636970657383 +030D636C65616E2D726563697065737F04000F632D6372616674696E672D646174610300840301 +72031163726561746976652D63617465676F7279C701046E616D65730F67726F75702D69636F6E +2D6974656DE80204001B63726561746976652D67726F75702D696E666F2D7061796C6F61640300 +86030172030269647A046974656DE8020B67726F75702D696E6465787A04001B63726561746976 +652D6974656D2D656E7472792D7061796C6F61640300880301708703017089030172020667726F +7570738A0307656E74726965738B03040012632D63726561746976652D636F6E74656E7403008C +030172090269647A0A737461636B2D73697A657A096175782D76616C75657A10626C6F636B2D72 +756E74696D652D69647A086E62742D64617461730F706C6163652D6F6E2D626C6F636B73CE000E +64657374726F792D626C6F636B73CE0014736869656C642D626C6F636B696E672D7469636B7806 +6E65742D6964C5000400126974656D2D737461636B2D7772617070657203008E030172070F7461 +726765742D6163746F722D696478117461726765742D72756E74696D652D696478046974656D8F +0308706F736974696F6E040876656C6F63697479040B656E746974792D64617461730F69732D66 +726F6D2D66697368696E677F040010632D6164642D6974656D2D6163746F720300900301720602 +69647A0A737461636B2D73697A657A096175782D76616C75657A10626C6F636B2D72756E74696D +652D69647A0A65787472612D6461746128066E65742D6964C50004001D6E6574776F726B2D6974 +656D2D737461636B2D64657363726970746F720300920301720511656E746974792D72756E7469 +6D652D696478046974656D930304736C6F747D0D73656C65637465642D736C6F747D0C636F6E74 +61696E65722D69647D04000F732D6D6F622D65717569706D656E74030094030172100475756964 +010B706C617965722D6E616D6573117461726765742D72756E74696D652D69647810706C617466 +6F726D2D636861742D69647308706F736974696F6E040876656C6F636974790408726F74617469 +6F6EBE010F792D686561642D726F746174696F6E760C636172726965642D6974656D930310706C +617965722D67616D652D74797065A6010B656E746974792D64617461731173796E6365642D7072 +6F7065727469657391020E6162696C69746965732D64617461B9010B6163746F722D6C696E6B73 +9302096465766963652D6964730E6275696C642D706C6174666F726DA40104000C632D6164642D +706C6179657203009603017205117461726765742D72756E74696D652D696478046974656D9303 +04736C6F747D0D73656C65637465642D736C6F747D0C636F6E7461696E65722D69647D04000F63 +2D6D6F622D65717569706D656E7403009803016D430B616E76696C2D696E7075740E616E76696C +2D6D6174657269616C14616E76696C2D726573756C742D7072657669657714736D697468696E67 +2D7461626C652D696E70757417736D697468696E672D7461626C652D6D6174657269616C1D736D +697468696E672D7461626C652D726573756C742D707265766965770561726D6F720C6C6576656C +2D656E746974790E626561636F6E2D7061796D656E741362726577696E672D7374616E642D696E +7075741462726577696E672D7374616E642D726573756C741262726577696E672D7374616E642D +6675656C1E636F6D62696E65642D686F742D6261722D616E642D696E76656E746F72790E637261 +6674696E672D696E707574176372616674696E672D6F75747075742D7072657669657713726563 +6970652D636F6E737472756374696F6E0D7265636970652D6E61747572650C7265636970652D69 +74656D730D7265636970652D736561726368117265636970652D7365617263682D626172107265 +636970652D65717569706D656E740B7265636970652D626F6F6B10656E6368616E74696E672D69 +6E70757413656E6368616E74696E672D6D6174657269616C0C6675726E6163652D6675656C1266 +75726E6163652D696E6772656469656E740E6675726E6163652D726573756C740B686F7273652D +657175697007686F742D62617209696E76656E746F72790B7368756C6B65722D626F7811747261 +64652D696E6772656469656E74311174726164652D696E6772656469656E74321474726164652D +726573756C742D70726576696577076F666668616E6416636F6D706F756E642D63726561746F72 +2D696E7075741F636F6D706F756E642D63726561746F722D6F75747075742D7072657669657722 +656C656D656E742D636F6E7374727563746F722D6F75747075742D70726576696577166D617465 +7269616C2D726564756365722D696E707574176D6174657269616C2D726564756365722D6F7574 +7075740F6C61622D7461626C652D696E7075740A6C6F6F6D2D696E707574086C6F6F6D2D647965 +0D6C6F6F6D2D6D6174657269616C136C6F6F6D2D726573756C742D7072657669657718626C6173 +742D6675726E6163652D696E6772656469656E7411736D6F6B65722D696E6772656469656E7412 +7472616465322D696E6772656469656E7431127472616465322D696E6772656469656E74321574 +72616465322D726573756C742D70726576696577106772696E6473746F6E652D696E7075741567 +72696E6473746F6E652D6164646974696F6E616C196772696E6473746F6E652D726573756C742D +707265766965771173746F6E656375747465722D696E7075741A73746F6E656375747465722D72 +6573756C742D7072657669657711636172746F6772617068792D696E70757416636172746F6772 +617068792D6164646974696F6E616C1A636172746F6772617068792D726573756C742D70726576 +6965770662617272656C06637572736F720E637265617465642D6F757470757417736D69746869 +6E672D7461626C652D74656D706C61746514637261667465722D6C6576656C2D656E7469747907 +64796E616D69630B7265636970652D666F6F640D7265636970652D626C6F636B73147265636970 +652D6675726E6163652D6974656D7304000E636F6E7461696E65722D6E616D6503009A03017202 +0E636F6E7461696E65722D6E616D659B030A64796E616D69632D6964C50004001366756C6C2D63 +6F6E7461696E65722D6E616D6503009C030172030E636F6E7461696E65722D6E616D659D030773 +6C6F742D69647D08737461636B2D69647A04001C6974656D2D737461636B2D726571756573742D +736C6F742D696E666F03009E0301720305636F756E747D06736F757263659F030B64657374696E +6174696F6E9F0304001E6974656D2D737461636B2D726571756573742D616374696F6E2D74616B +650300A00301720305636F756E747D06736F757263659F030B64657374696E6174696F6E9F0304 +001F6974656D2D737461636B2D726571756573742D616374696F6E2D706C6163650300A2030172 +0205736C6F74319F0305736C6F74329F0304001E6974656D2D737461636B2D726571756573742D +616374696F6E2D737761700300A40301720305636F756E747D06736F757263659F030872616E64 +6F6D6C797F04001E6974656D2D737461636B2D726571756573742D616374696F6E2D64726F7003 +00A60301720205636F756E747D06736F757263659F030400216974656D2D737461636B2D726571 +756573742D616374696F6E2D64657374726F790300A80301720205636F756E747D06736F757263 +659F030400216974656D2D737461636B2D726571756573742D616374696F6E2D636F6E73756D65 +0300AA030171120474616B6501A1030005706C61636501A30300047377617001A503000464726F +7001A703000764657374726F7901A9030007636F6E73756D6501AB030006637265617465012F00 +116C61622D7461626C652D636F6D62696E6500000E626561636F6E2D7061796D656E740131000A +6D696E652D626C6F636B0133000C63726166742D7265636970650135001163726166742D726563 +6970652D6175746F0137000E63726166742D6372656174697665013900086F7074696F6E616C01 +3B000A6772696E6473746F6E65013D00046C6F6F6D013F001563726166742D6E6F6E2D696D706C +656D656E74656400001863726166742D726573756C74732D6465707265636174656401C2000004 +00196974656D2D737461636B2D726571756573742D616374696F6E0300AC030170AD030172040A +726571756573742D69647A07616374696F6E73AE030E66696C7465722D737472696E6773CE000C +66696C7465722D63617573657A0400126974656D2D737461636B2D726571756573740300AF0301 +70B003017201087265717565737473B103040014732D6974656D2D737461636B2D726571756573 +740300B2030170E000016BB403016BFA02016BB003016BBE01016B780172150570697463687603 +7961777608706F736974696F6E04086D6F76652D766563BE0108686561642D796177760A696E70 +75742D64617461120A696E7075742D6D6F64657A09706C61792D6D6F64657A11696E7465726163 +74696F6E2D6D6F64656C7A0E696E7465726163742D7069746368760C696E7465726163742D7961 +7776047469636B780564656C7461040D626C6F636B2D616374696F6E73B503106974656D2D696E +746572616374696F6EB603126974656D2D737461636B2D72657175657374B7031076656869636C +652D726F746174696F6EB8031176656869636C652D756E697175652D6964B9030B616E616C6F67 +2D6D6F7665BE011263616D6572612D6F7269656E746174696F6E04087261772D6D6F7665BE0104 +0013732D706C617965722D617574682D696E7075740300BA03017093030172040C636F6E746169 +6E65722D69647A05736C6F7473BC031366756C6C2D636F6E7461696E65722D6E616D659D030C73 +746F726167652D6974656D9303040013632D696E76656E746F72792D636F6E74656E740300BD03 +016B9D03016B93030172050C636F6E7461696E65722D69647A04736C6F747A1366756C6C2D636F +6E7461696E65722D6E616D65BF030C73746F726167652D6974656DC003046974656D9303040010 +632D696E76656E746F72792D736C6F740300C1030170D7010172021366756C6C2D636F6E746169 +6E65722D6E616D659D0305736C6F7473C3030400226974656D2D737461636B2D726573706F6E73 +652D636F6E7461696E65722D696E666F0300C4030170C50301720306726573756C747D11636C69 +656E742D726571756573742D69647A0A636F6E7461696E657273C6030400186974656D2D737461 +636B2D726573706F6E73652D696E666F0300C7030170C80301720109726573706F6E736573C903 +040015632D6974656D2D737461636B2D726573706F6E73650300CA030172050269647A05636F75 +6E747A096175782D76616C75657A10626C6F636B2D72756E74696D652D69647A0A65787472612D +64617461280400126E6574776F726B2D6974656D2D737461636B0300CC0301711D0D732D616374 +6F722D6576656E7401070009732D616E696D617465010E0014732D626C6F636B2D7069636B2D72 +6571756573740111001A732D636C69656E742D63616368652D626C6F622D737461747573011400 +15732D636C69656E742D63616368652D73746174757301160011732D636F6D6D616E642D726571 +75657374011A0011732D636F6E7461696E65722D636C6F7365011C0007732D656D6F7465011E00 +0C732D656D6F74652D6C6973740121000A732D696E74657261637401250017732D696E76656E74 +6F72792D7472616E73616374696F6E01F6020014732D6974656D2D737461636B2D726571756573 +7401B3030010732D6C6F6164696E672D73637265656E01C7000007732D6C6F67696E01C900000F +732D6D6F622D65717569706D656E740195030015732D6D6F64616C2D666F726D2D726573706F6E +736501D800001A732D7061636B65742D76696F6C6174696F6E2D7761726E696E6701DA00000F73 +2D706C617965722D616374696F6E01DE000013732D706C617965722D617574682D696E70757401 +BB03000F732D706C617965722D686F7462617201EA000011732D726571756573742D6162696C69 +747901EE000016732D726571756573742D6368756E6B2D72616469757301F000001A732D726571 +756573742D6E6574776F726B2D73657474696E677301F200001F732D7265736F757263652D7061 +636B2D636C69656E742D726573706F6E736501F4000009732D7265737061776E01F8000021732D +7365742D6C6F63616C2D706C617965722D61732D696E697469616C697A656401FA00001E732D73 +65742D706C617965722D696E76656E746F72792D6F7074696F6E7301FC000006732D7465787401 +80010007756E6B6E6F776E0000040012736572766572626F756E642D7061636B65740300CE0301 +713B0B632D6164642D6163746F720195020010632D6164642D6974656D2D6163746F7201910300 +0C632D6164642D706C617965720197030014632D617661696C61626C652D636F6D6D616E647301 +B4010017632D62696F6D652D646566696E6974696F6E2D6C697374000012632D626C6F636B2D61 +63746F722D64617461019501000D632D626C6F636B2D6576656E74019701000C632D626F73732D +6576656E740199010012632D6368616E67652D64696D656E73696F6E019B010016632D6368756E +6B2D7261646975732D75706461746564019D01001C632D636C69656E742D63616368652D6D6973 +732D726573706F6E736501A2010010632D636F6E7461696E65722D6F70656E01BD010020632D63 +6F72726563742D706C617965722D6D6F76652D70726564696374696F6E01C101000F632D637261 +6674696E672D646174610185030012632D63726561746976652D636F6E74656E74018D03000C63 +2D646973636F6E6E65637401C9010013632D67616D6572756C65732D6368616E67656401D00100 +13632D696E76656E746F72792D636F6E74656E7401BE030010632D696E76656E746F72792D736C +6F7401C203000F632D6974656D2D726567697374727901D5010015632D6974656D2D737461636B +2D726573706F6E736501CB03000D632D6C6576656C2D6368756E6B01D901000D632D6C6576656C +2D6576656E7401DB010013632D6C6576656C2D736F756E642D6576656E7401DF01000C632D6D6F +622D65666665637401E101000F632D6D6F622D65717569706D656E740199030014632D6D6F6461 +6C2D666F726D2D7265717565737401E3010015632D6D6F76652D6163746F722D6162736F6C7574 +6501E5010012632D6D6F76652D6163746F722D64656C746101E701000D632D6D6F76652D706C61 +79657201E9010020632D6E6574776F726B2D6368756E6B2D7075626C69736865722D7570646174 +6501EC010012632D6E6574776F726B2D73657474696E677301EE01000D632D706C61792D737461 +74757301F001000F632D706C617965722D686F7462617201F201000D632D706C617965722D6C69 +737401FC01000E632D72656D6F76652D6163746F7201FE010012632D72656D6F76652D6F626A65 +6374697665018002001C632D7265736F757263652D7061636B2D737461636B2D7061636B657401 +C9020015632D7265736F757263652D7061636B732D696E666F0189020010632D7365742D616374 +6F722D646174610197020010632D7365742D6163746F722D6C696E6B0199020012632D7365742D +6163746F722D6D6F74696F6E019B020010632D7365742D646966666963756C7479019D02001763 +2D7365742D646973706C61792D6F626A656374697665019F02000C632D7365742D6865616C7468 +01A1020016632D7365742D706C617965722D67616D652D7479706501A302000B632D7365742D73 +636F726501A8020014632D7365742D737061776E2D706F736974696F6E01AC02000A632D736574 +2D74696D6501AE02000B632D7365742D7469746C6501B202000E632D73686F772D637265646974 +7301B402000C632D73746172742D67616D6501D0020011632D74616B652D6974656D2D6163746F +7201D402000A632D7472616E7366657201D6020012632D7570646174652D6162696C6974696573 +01D8020013632D7570646174652D6174747269627574657301E202000E632D7570646174652D62 +6C6F636B01E402000E632D7570646174652D747261646501E6020007756E6B6E6F776E00000400 +12636C69656E74626F756E642D7061636B65740300D00303002470756D706B696E3A706C756769 +6E2F626564726F636B2D7061636B65747340302E312E30053A014204016D270573706565640873 +6C6F776E6573730568617374650E6D696E696E672D6661746967756508737472656E6774680E69 +6E7374616E742D6865616C74680E696E7374616E742D64616D6167650A6A756D702D626F6F7374 +066E61757365610C726567656E65726174696F6E0A726573697374616E63650F666972652D7265 +73697374616E63650F77617465722D627265617468696E670C696E7669736962696C6974790962 +6C696E646E6573730C6E696768742D766973696F6E0668756E676572087765616B6E6573730670 +6F69736F6E067769746865720C6865616C74682D626F6F73740A6162736F727074696F6E0A7361 +7475726174696F6E07676C6F77696E670A6C657669746174696F6E046C75636B06756E6C75636B +0C736C6F772D66616C6C696E670D636F6E647569742D706F7765720E646F6C7068696E732D6772 +616365086261642D6F6D656E136865726F2D6F662D7468652D76696C6C616765086461726B6E65 +73730A747269616C2D6F6D656E09726169642D6F6D656E0C77696E642D63686172676564077765 +6176696E67066F6F7A696E6708696E6665737465640400127374617475732D6566666563742D74 +7970650300000172060B6566666563742D7479706501086475726174696F6E7909616D706C6966 +6965727D07616D6269656E747F0E73686F772D7061727469636C65737F0973686F772D69636F6E +7F0400167374617475732D6566666563742D696E7374616E636503000203002270756D706B696E +3A706C7567696E2F7374617475732D65666665637440302E312E30053B01420E02030201080400 +0E746578742D636F6D706F6E656E74030000016D03047461736B096368616C6C656E676504676F +616C04000A6672616D652D74797065030002016901016B73017209057469746C65040B64657363 +72697074696F6E04056672616D65030A73686F772D746F6173747F0668696464656E7F10616E6E +6F756E63652D746F2D636861747F0A6261636B67726F756E640501787601797604001361647661 +6E63656D656E742D646973706C6179030006017073016B070172040269647309706172656E742D +6964050863726974657269610807646973706C617909040010616476616E63656D656E742D696E +666F03000A0172040E616476616E63656D656E742D69647304646F6E657F10617761726465642D +6372697465726961081272656D61696E696E672D637269746572696108040014616476616E6365 +6D656E742D70726F677265737303000C03002070756D706B696E3A706C7567696E2F616476616E +63656D656E7440302E312E30053C014204016D09056D696E656407637261667465640475736564 +0662726F6B656E097069636B65642D75700764726F70706564066B696C6C6564096B696C6C6564 +2D627906637573746F6D0400127374617469737469632D63617465676F7279030000016D4D0A6C +656176652D67616D6509706C61792D74696D6510746F74616C2D776F726C642D74696D65107469 +6D652D73696E63652D64656174680F74696D652D73696E63652D726573740A736E65616B2D7469 +6D650B77616C6B2D6F6E652D636D0D63726F7563682D6F6E652D636D0D737072696E742D6F6E65 +2D636D1477616C6B2D6F6E2D77617465722D6F6E652D636D0B66616C6C2D6F6E652D636D0C636C +696D622D6F6E652D636D0A666C792D6F6E652D636D1777616C6B2D756E6465722D77617465722D +6F6E652D636D0F6D696E65636172742D6F6E652D636D0B626F61742D6F6E652D636D0A7069672D +6F6E652D636D1268617070792D67686173742D6F6E652D636D0C686F7273652D6F6E652D636D0D +6176696174652D6F6E652D636D0B7377696D2D6F6E652D636D0E737472696465722D6F6E652D63 +6D0F6E617574696C75732D6F6E652D636D046A756D700464726F700C64616D6167652D6465616C +741564616D6167652D6465616C742D6162736F726265641564616D6167652D6465616C742D7265 +7369737465640C64616D6167652D74616B656E1864616D6167652D626C6F636B65642D62792D73 +6869656C640F64616D6167652D6162736F726265640F64616D6167652D72657369737465640664 +6561746873096D6F622D6B696C6C730C616E696D616C732D627265640C706C617965722D6B696C +6C730B666973682D6361756768741274616C6B65642D746F2D76696C6C61676572147472616465 +642D776974682D76696C6C616765720E6561742D63616B652D736C6963650D66696C6C2D636175 +6C64726F6E0C7573652D6361756C64726F6E0B636C65616E2D61726D6F720C636C65616E2D6261 +6E6E657211636C65616E2D7368756C6B65722D626F781A696E7465726163742D776974682D6272 +6577696E677374616E6414696E7465726163742D776974682D626561636F6E0F696E7370656374 +2D64726F707065720E696E73706563742D686F7070657211696E73706563742D64697370656E73 +65720E706C61792D6E6F7465626C6F636B0E74756E652D6E6F7465626C6F636B0A706F742D666C +6F77657215747269676765722D747261707065642D63686573740F6F70656E2D656E6465726368 +6573740C656E6368616E742D6974656D0B706C61792D7265636F726415696E7465726163742D77 +6974682D6675726E6163651C696E7465726163742D776974682D6372616674696E672D7461626C +650A6F70656E2D63686573740C736C6565702D696E2D626564106F70656E2D7368756C6B65722D +626F780B6F70656E2D62617272656C1B696E7465726163742D776974682D626C6173742D667572 +6E61636514696E7465726163742D776974682D736D6F6B657215696E7465726163742D77697468 +2D6C65637465726E16696E7465726163742D776974682D63616D70666972651F696E7465726163 +742D776974682D636172746F6772617068792D7461626C6512696E7465726163742D776974682D +6C6F6F6D19696E7465726163742D776974682D73746F6E656375747465720962656C6C2D72696E +670C726169642D7472696767657208726169642D77696E13696E7465726163742D776974682D61 +6E76696C18696E7465726163742D776974682D6772696E6473746F6E650A7461726765742D6869 +741C696E7465726163742D776974682D736D697468696E672D7461626C65040010637573746F6D +2D73746174697374696303000203001F70756D706B696E3A706C7567696E2F7374617469737469 +637340302E312E30053D014202016D3E0E61726D6164696C6C6F2D7065656B1161726D6F727374 +616E642D776F62626C650A626F64792D627265616B1463616E63656C2D7368616B652D7765746E +6573730B63686573742D627265616B0564656174681C646F6C7068696E2D6C6F6F6B696E672D66 +6F722D74726561737572650F64726F776E2D7061727469636C6573096561742D67726173730765 +6E642D72616D0A666565742D627265616B1166697265776F726B732D6578706C6F646513666973 +68696E672D726F642D7265656C2D696E07666F782D6561740F66756C6C2D64656275672D696E66 +6F15677561726469616E2D61747461636B2D736F756E640A686561642D627265616B0A686F6E65 +792D6A756D700B686F6E65792D736C6964650E696E2D6C6F76652D686561727473046A756D700B +6B696E657469632D6869740A6C6567732D627265616B0B6C6F76652D6865617274730E6D61696E +68616E642D627265616B0C6F666665722D666C6F7765720D6F666668616E642D627265616B1770 +65726D697373696F6E2D6C6576656C2D61646D696E73147065726D697373696F6E2D6C6576656C +2D616C6C1C7065726D697373696F6E2D6C6576656C2D67616D656D6173746572731B7065726D69 +7373696F6E2D6C6576656C2D6D6F64657261746F7273177065726D697373696F6E2D6C6576656C +2D6F776E65727304706F6F661470726F7465637465642D66726F6D2D64656174680E7261766167 +65722D726F617265640F726176616765722D7374756E6E656412726564756365642D6465627567 +2D696E666F0C736164646C652D627265616B057368616B650D7368616B652D7765746E65737315 +73696C766572666973682D6D657267652D616E696D15736E69666665722D64696767696E672D73 +6F756E640C736F6E69632D6368617267651073717569642D616E696D2D73796E63680F73746172 +742D61747461636B696E670973746172742D72616D0E73746F702D61747461636B696E67117374 +6F702D6F666665722D666C6F7765720A737761702D68616E64730D74616D696E672D6661696C65 +641074616D696E672D7375636365656465640874656C65706F72740F74656E6472696C732D7368 +6976657209746E742D7072696D650F7472757374696E672D6661696C6564127472757374696E67 +2D737563636565646564117573652D6974656D2D636F6D706C6574650E76696C6C616765722D61 +6E6772790E76696C6C616765722D68617070790E76696C6C616765722D73776561740F77697463 +682D6861742D6D61676963117A6F6D6269652D636F6E76657274696E6704000D656E746974792D +73746174757303000003002470756D706B696E3A706C7567696E2F656E746974792D7374617475 +73657340302E312E30053E020300010967616D652D6D6F64650203001305776F726C6402030013 +06656E7469747902030013167261792D74726163652D626C6F636B2D726573756C740203001317 +7261792D74726163652D656E746974792D726573756C7402030014107065726D697373696F6E2D +6C6576656C02030009036775690203001504666F726D02030016066469616C6F67020300171263 +6C69656E74626F756E642D7061636B65740203001812636C69656E74626F756E642D7061636B65 +7402030019127374617475732D6566666563742D7479706502030019167374617475732D656666 +6563742D696E7374616E63650203000A12626564726F636B2D73636F7265626F6172640203001A +14616476616E63656D656E742D70726F67726573730203001B127374617469737469632D636174 +65676F72790203001B10637573746F6D2D7374617469737469630203000810706C617965722D69 +6E76656E746F72790203001C0D656E746974792D7374617475730142F903020302011504000468 +616E640300000203020125040008706F736974696F6E030002020302013F04000967616D652D6D +6F6465030004020302011C040009626C6F636B2D706F73030006020302011404000A6974656D2D +737461636B0300080203020140040005776F726C6403000A0203020141040006656E7469747903 +000C02030201420400167261792D74726163652D626C6F636B2D726573756C7403000E02030201 +430400177261792D74726163652D656E746974792D726573756C74030010020302014404001070 +65726D697373696F6E2D6C6576656C030012020302010804000E746578742D636F6D706F6E656E +7403001402030201450400036775690300160203020146040004666F726D030018020302014704 +00066469616C6F6703001A020302014804000B6A6176612D7061636B657403001C020302014904 +000E626564726F636B2D7061636B657403001E020302013404000475756964030020020302014A +0400127374617475732D6566666563742D74797065030022020302014B0400167374617475732D +6566666563742D696E7374616E6365030024020302012A04000A73636F7265626F617264030026 +020302014C040012626564726F636B2D73636F7265626F617264030028020302014D0400146164 +76616E63656D656E742D70726F677265737303002A020302013104000B64616D6167652D747970 +6503002C020302014E0400127374617469737469632D63617465676F727903002E020302014F04 +0010637573746F6D2D7374617469737469630300300203020119040009696E76656E746F727903 +00320203020150040010706C617965722D696E76656E746F7279030034020302012C040005736F +756E64030036020302012D04000E736F756E642D63617465676F7279030038020302012B040008 +7061727469636C6503003A020302015104000D656E746974792D73746174757303003C016D0205 +636C65617208646F776E66616C6C04000E706C617965722D7765617468657203003E016D090561 +72726F7708736E6F7762616C6C036567670B656E6465722D706561726C0D73706C6173682D706F +74696F6E086669726562616C6C0E736D616C6C2D6669726562616C6C0774726964656E740B7769 +6E642D63686172676504000F70726F6A656374696C652D74797065030040016D0E1A6E6F2D7265 +737061776E2D626C6F636B2D617661696C61626C650D626567696E2D7261696E696E670B656E64 +2D7261696E696E67106368616E67652D67616D652D6D6F64650877696E2D67616D650A64656D6F +2D6576656E74106172726F772D6869742D706C61796572117261696E2D6C6576656C2D6368616E +6765147468756E6465722D6C6576656C2D6368616E67651C706C61792D70756666657266697368 +2D737472696E672D736F756E6422706C61792D656C6465722D677561726469616E2D6D6F622D61 +7070656172616E636516656E61626C65642D7265737061776E2D73637265656E106C696D697465 +642D6372616674696E671473746172742D77616974696E672D6368756E6B73040011636C69656E +742D67616D652D6576656E74030042016D0A0A6275672D7265706F727414636F6D6D756E697479 +2D67756964656C696E657307737570706F72740673746174757308666565646261636B09636F6D +6D756E697479077765627369746506666F72756D73046E6577730D616E6E6F756E63656D656E74 +730400116B6E6F776E2D7365727665722D6C696E6B030044016915017102056B6E6F776E01C500 +0006637573746F6D01C600000400117365727665722D6C696E6B2D6C6162656C03004701720205 +6C6162656CC8000375726C7304000B7365727665722D6C696E6B0300490172070C696E76756C6E +657261626C657F06666C79696E677F0C616C6C6F772D666C79696E677F0863726561746976657F +12616C6C6F772D6D6F646966792D776F726C647F09666C792D7370656564760A77616C6B2D7370 +65656476040010706C617965722D6162696C697469657303004B016B730172020576616C756573 +097369676E6174757265CD0004000B706C617965722D736B696E03004E016E070463617065066A +61636B65740B6C6566742D736C656576650C72696768742D736C656576650E6C6566742D70616E +74732D6C65670F72696768742D70616E74732D6C65670368617404000A736B696E2D7061727473 +030050016D14056275696C64046D696E6512646F6F72732D616E642D73776974636865730F6F70 +656E2D636F6E7461696E6572730E61747461636B2D706C61796572730B61747461636B2D6D6F62 +73116F70657261746F722D636F6D6D616E64730874656C65706F72740C696E76756C6E65726162 +6C6506666C79696E67076D61792D666C790A696E7374616275696C64096C696768746E696E6709 +666C792D73706565640A77616C6B2D7370656564056D757465640D776F726C642D6275696C6465 +72076E6F2D636C69701270726976696C656765642D6275696C64657212766572746963616C2D66 +6C792D737065656404000F626564726F636B2D6162696C697479030052016D7C076F6E2D666972 +6508736E65616B696E6706726964696E6709737072696E74696E670A7573696E672D6974656D09 +696E76697369626C650774656D7074656407696E2D6C6F766507736164646C656407706F776572 +65640769676E6974656404626162790A636F6E76657274696E6708637269746963616C0973686F +772D6E616D6510616C776179732D73686F772D6E616D65056E6F2D61690673696C656E740D7761 +6C6C2D636C696D62696E6705636C696D62047377696D03666C790477616C6B0772657374696E67 +0773697474696E6705616E6772790A696E746572657374656407636861726765640574616D6564 +086F727068616E6564076C656173686564077368656172656407676C6964696E6705656C646572 +066D6F76696E6709627265617468696E67076368657374656409737461636B61626C650B73686F +772D626F74746F6D087374616E64696E67077368616B696E670669646C696E670763617374696E +67086368617267696E67136B6579626F6172642D636F6E74726F6C6C65640A706F7765722D6A75 +6D700464617368096C696E676572696E670D6861732D636F6C6C6973696F6E0B6861732D677261 +766974790B666972652D696D6D756E650764616E63696E6709656E6368616E7465640E72657475 +726E2D74726964656E7411636F6E7461696E65722D707269766174650C7472616E73666F726D69 +6E671264616D6167652D6E65617262792D6D6F6273087377696D6D696E67066272696265640870 +7265676E616E740A6C6179696E672D6567671270617373656E6765722D63616E2D7069636B1274 +72616E736974696F6E2D73697474696E6706656174696E670B6C6179696E672D646F776E08736E +65657A696E67087472757374696E6707726F6C6C696E67067363617265640E696E2D7363616666 +6F6C64696E67106F7665722D73636166666F6C64696E671564657363656E642D7468726F756768 +2D626C6F636B08626C6F636B696E67137472616E736974696F6E2D626C6F636B696E6714626C6F +636B65642D7573696E672D736869656C641C626C6F636B65642D7573696E672D64616D61676564 +2D736869656C6408736C656570696E670D77616E74732D746F2D77616B650E74726164652D696E +7465726573740C646F6F722D627265616B657214627265616B696E672D6F62737472756374696F +6E0B646F6F722D6F70656E6572076361707461696E077374756E6E656407726F6172696E670E64 +656C617965642D61747461636B0D61766F6964696E672D6D6F62730E61766F6964696E672D626C +6F636B1D666163696E672D7461726765742D746F2D72616E67652D61747461636B156869646465 +6E2D7768656E2D696E76697369626C6505696E2D7569087374616C6B696E6707656D6F74696E67 +0B63656C6562726174696E670861646D6972696E671363656C6562726174696E672D7370656369 +616C0E6F75742D6F662D636F6E74726F6C0A72616D2D61747461636B0C706C6179696E672D6465 +616412696E2D617363656E64696E672D626C6F636B156F7665722D64657363656E64696E672D62 +6C6F636B0863726F616B696E670A6469676573742D6D6F62096A756D702D676F616C08656D6572 +67696E6708736E696666696E670764696767696E670A736F6E69632D626F6F6D106861732D6461 +73682D74696D656F75741A707573682D746F77617264732D636C6F736573742D73706163650873 +63656E74696E6706726973696E670D6665656C696E672D686170707909736561726368696E6708 +637261776C696E6715626F64792D726F746174696F6E2D626C6F636B65641572656E6465722D77 +68656E2D696E76697369626C651A626F64792D726F746174696F6E2D617869732D616C69676E65 +640A636F6C6C696461626C6513776173642D6169722D636F6E74726F6C6C65641E646F65732D73 +65727665722D617574682D6F6E6C792D6469736D6F756E7421626F64792D726F746174696F6E2D +616C776179732D666F6C6C6F77732D686561642063616E2D7573652D766572746963616C2D6D6F +76656D656E742D616374696F6E1A726F746174696F6E2D6C6F636B65642D746F2D76656869636C +65040013626564726F636B2D7374617475732D666C6167030054016D3407762D312D372D320776 +2D312D372D3605762D312D3805762D312D3907762D312D392D3107762D312D392D3207762D312D +392D3306762D312D313006762D312D313108762D312D31312D3106762D312D313208762D312D31 +322D3108762D312D31322D3206762D312D313308762D312D31332D3108762D312D31332D320676 +2D312D313408762D312D31342D3108762D312D31342D3208762D312D31342D3308762D312D3134 +2D3406762D312D313508762D312D31352D3108762D312D31352D3206762D312D313608762D312D +31362D3108762D312D31362D3208762D312D31362D3308762D312D31362D3406762D312D313708 +762D312D31372D3106762D312D313808762D312D31382D3206762D312D313908762D312D31392D +3108762D312D31392D3308762D312D31392D3406762D312D323008762D312D32302D3208762D31 +2D32302D3308762D312D32302D3506762D312D323108762D312D32312D3208762D312D32312D34 +08762D312D32312D3508762D312D32312D3608762D312D32312D3708762D312D32312D3909762D +312D32312D313106762D32362D3106762D32362D3207756E6B6E6F776E0400166A6176612D6D69 +6E6563726166742D76657273696F6E030056016D0306762D312D323109762D312D32362D333007 +756E6B6E6F776E040019626564726F636B2D6D696E6563726166742D76657273696F6E03005801 +6D0307656E61626C65640D636F6D6D616E64732D6F6E6C790668696464656E040009636861742D +6D6F646503005A017208066C6F63616C65730D766965772D64697374616E63657D09636861742D +6D6F6465DB000B636861742D636F6C6F72737F0A736B696E2D7061727473D100096D61696E2D68 +616E64010E746578742D66696C746572696E677F0E7365727665722D6C697374696E677F040014 +6A6176612D706C617965722D73657474696E677303005C016D1007616E64726F696403696F7303 +6F737806616D617A6F6E07676561722D767209686F6C6F2D6C656E730A77696E646F77732D3130 +0677696E2D3332096465646963617465640574762D6F730B706C617973746174696F6E086E696E +74656E646F0478626F780D77696E646F77732D70686F6E65056C696E757807756E6B6E6F776E04 +0011626564726F636B2D6465766963652D6F7303005E016D0507756E6B6E6F776E056D6F757365 +05746F7563680867616D652D706164116D6F74696F6E2D636F6E74726F6C6C6572040012626564 +726F636B2D696E7075742D6D6F6465030060016D0307636C617373696306706F636B657407756E +6B6E6F776E040012626564726F636B2D75692D70726F66696C65030062016D040673696D706C65 +0566616E63790A7261792D74726163656407756E6B6E6F776E040015626564726F636B2D677261 +70686963732D6D6F64650300640172160C67616D652D76657273696F6E73096465766963652D6F +73DF00096465766963652D6964730C6465766963652D6D6F64656C730D6C616E67756167652D63 +6F6465731263757272656E742D696E7075742D6D6F6465E1001264656661756C742D696E707574 +2D6D6F6465E1000A75692D70726F66696C65E300096775692D7363616C657A0E69732D65646974 +6F722D6D6F64657F116D61782D766965772D64697374616E63657A0B6D656D6F72792D74696572 +7A0D67726170686963732D6D6F6465E5000A706C61796661622D69647310636C69656E742D7261 +6E646F6D2D69647813706C6174666F726D2D6F66666C696E652D69647312706C6174666F726D2D +6F6E6C696E652D69647307736B696E2D6964730861726D2D73697A65730F69732D706572736F6E +612D736B696E7F0F69732D7072656D69756D2D736B696E7F0F69732D747275737465642D736B69 +6E7F040017626564726F636B2D706C617965722D73657474696E6773030066016D940107756E6B +6E6F776E1863616E742D636F6E6E6563742D6E6F2D696E7465726E65740E6E6F2D7065726D6973 +73696F6E7313756E7265636F76657261626C652D6572726F721374686972642D70617274792D62 +6C6F636B65641774686972642D70617274792D6E6F2D696E7465726E65741274686972642D7061 +7274792D6261642D69702674686972642D70617274792D6E6F2D7365727665722D6F722D736572 +7665722D6C6F636B65641076657273696F6E2D6D69736D617463680A736B696E2D697373756518 +696E766974652D73657373696F6E2D6E6F742D666F756E641A6564752D6C6576656C2D73657474 +696E67732D6D697373696E67166C6F63616C2D7365727665722D6E6F742D666F756E64116C6567 +6163792D646973636F6E6E65637419757365722D6C656176652D67616D652D617474656D707465 +641B706C6174666F726D2D6C6F636B65642D736B696E732D6572726F72177265616C6D732D776F +726C642D756E61737369676E65641A7265616C6D732D7365727665722D63616E742D636F6E6E65 +6374147265616C6D732D7365727665722D68696464656E1B7265616C6D732D7365727665722D64 +697361626C65642D62657461167265616C6D732D7365727665722D64697361626C65641763726F +73732D706C6174666F726D2D64697361626C65640C63616E742D636F6E6E656374117365737369 +6F6E2D6E6F742D666F756E6428636C69656E742D73657474696E67732D696E636F6D7061746962 +6C652D776974682D7365727665720B7365727665722D66756C6C15696E76616C69642D706C6174 +666F726D2D736B696E1865646974696F6E2D76657273696F6E2D6D69736D617463681065646974 +696F6E2D6D69736D617463681C6C6576656C2D6E657765722D7468616E2D6578652D7665727369 +6F6E106E6F2D6661696C2D6F636375727265640B62616E6E65642D736B696E0774696D656F7574 +107365727665722D6E6F742D666F756E640F6F757464617465642D7365727665720F6F75746461 +7465642D636C69656E74136E6F2D7072656D69756D2D706C6174666F726D146D756C7469706C61 +7965722D64697361626C6564076E6F2D7769666910776F726C642D636F7272757074696F6E096E +6F2D726561736F6E0C646973636F6E6E65637465640E696E76616C69642D706C61796572186C6F +676765642D696E2D6F746865722D6C6F636174696F6E127365727665722D69642D636F6E666C69 +63740B6E6F742D616C6C6F776564116E6F742D61757468656E746963617465640E696E76616C69 +642D74656E616E740E756E6B6E6F776E2D7061636B657411756E65787065637465642D7061636B +65741E696E76616C69642D636F6D6D616E642D726571756573742D7061636B65740E686F73742D +73757370656E646564176C6F67696E2D7061636B65742D6E6F2D72657175657374146C6F67696E +2D7061636B65742D6E6F2D636572740E6D697373696E672D636C69656E74066B69636B6564126B +69636B65642D666F722D6578706C6F69740F6B69636B65642D666F722D69646C65157265736F75 +7263652D7061636B2D70726F626C656D11696E636F6D70617469626C652D7061636B0E6F75742D +6F662D73746F726167650D696E76616C69642D6C6576656C11646973636F6E6E6563742D706163 +6B65740E626C6F636B2D6D69736D617463680F696E76616C69642D686569676874730E696E7661 +6C69642D7769647468730F636F6E6E656374696F6E2D6C6F7374117A6F6D6269652D636F6E6E65 +6374696F6E0873687574646F776E0E726561736F6E2D6E6F742D736574156C6F6164696E672D73 +746174652D74696D656F75741C7265736F757263652D7061636B2D6C6F6164696E672D6661696C +65642B736561726368696E672D666F722D73657373696F6E2D6C6F6164696E672D73637265656E +2D6661696C65641B6E65746865722D6E65742D70726F746F636F6C2D76657273696F6E16737562 +73797374656D2D7374617475732D6572726F7219656D7074792D617574682D66726F6D2D646973 +636F7665727918656D7074792D75726C2D66726F6D2D646973636F766572791B65787069726564 +2D617574682D66726F6D2D646973636F7665727926756E6B6E6F776E2D7369676E616C2D736572 +766963652D7369676E2D696E2D6661696C7572651678626C2D6A6F696E2D6C6F6262792D666169 +6C75726529756E7370656369666965642D636C69656E742D696E7374616E63652D646973636F6E +6E656374696F6E1C6E65746865722D6E65742D73657373696F6E2D6E6F742D666F756E64216E65 +746865722D6E65742D6372656174652D706565722D636F6E6E656374696F6E0E6E65746865722D +6E65742D6963651A6E65746865722D6E65742D636F6E6E6563742D726571756573741B6E657468 +65722D6E65742D636F6E6E6563742D726573706F6E73651E6E65746865722D6E65742D6E65676F +74696174696F6E2D74696D656F75741D6E65746865722D6E65742D696E61637469766974792D74 +696D656F75741F7374616C652D636F6E6E656374696F6E2D6265696E672D7265706C6163656418 +7265616C6D732D73657373696F6E2D6E6F742D666F756E640A6261642D7061636B6574216E6574 +6865722D6E65742D6661696C65642D746F2D6372656174652D6F66666572226E65746865722D6E +65742D6661696C65642D746F2D6372656174652D616E737765722A6E65746865722D6E65742D66 +61696C65642D746F2D7365742D6C6F63616C2D6465736372697074696F6E2B6E65746865722D6E +65742D6661696C65642D746F2D7365742D72656D6F74652D6465736372697074696F6E336E6574 +6865722D6E65742D6E65676F74696174696F6E2D74696D656F75742D77616974696E672D666F72 +2D726573706F6E7365316E65746865722D6E65742D6E65676F74696174696F6E2D74696D656F75 +742D77616974696E672D666F722D616363657074266E65746865722D6E65742D696E636F6D696E +672D636F6E6E656374696F6E2D69676E6F726564246E65746865722D6E65742D7369676E616C69 +6E672D70617273696E672D6661696C757265226E65746865722D6E65742D7369676E616C696E67 +2D756E6B6E6F776E2D6572726F722C6E65746865722D6E65742D7369676E616C696E672D756E69 +636173742D64656C69766572792D6661696C65642E6E65746865722D6E65742D7369676E616C69 +6E672D62726F6164636173742D64656C69766572792D6661696C65642C6E65746865722D6E6574 +2D7369676E616C696E672D67656E657269632D64656C69766572792D6661696C65641C65646974 +6F722D6D69736D617463682D656469746F722D776F726C641D656469746F722D6D69736D617463 +682D76616E696C6C612D776F726C6421776F726C642D7472616E736665722D6E6F742D7072696D +6172792D636C69656E7417726571756573742D7365727665722D73687574646F776E1B636C6965 +6E742D67616D652D73657475702D63616E63656C6C656418636C69656E742D67616D652D736574 +75702D6661696C6564086E6F2D76656E7565226E65746865722D6E65742D7369676E616C696E67 +2D7369676E696E2D6661696C65641573657373696F6E2D6163636573732D64656E696564147365 +72766963652D7369676E696E2D69737375651F6E65746865722D6E65742D6E6F2D7369676E616C +696E672D6368616E6E656C186E65746865722D6E65742D6E6F742D6C6F676765642D696E216E65 +746865722D6E65742D636C69656E742D7369676E616C696E672D6572726F72197375622D636C69 +656E742D6C6F67696E2D64697361626C656433646565702D6C696E6B2D747279696E672D746F2D +6F70656E2D64656D6F2D776F726C642D7768696C652D7369676E65642D696E166173796E632D6A +6F696E2D7461736B2D64656E696564187265616C6D732D74696D656C696E652D72657175697265 +641267756573742D776974686F75742D686F7374196661696C65642D746F2D6A6F696E2D657870 +657269656E63651E6E65746865722D6E65742D646174612D6368616E6E656C2D636C6F7365641E +646973636F766572792D656E7669726F6E6D656E742D6D69736D6174636811686F73742D776974 +686F75742D6B6579730F686F73742D7369676E65642D6F7574197363726970742D776174636864 +6F672D657863657074696F6E1C7363726970742D6D656D6F72792D6C696D69742D657863656564 +65641B73746F726167652D6C6F772D647572696E672D67616D65706C61791C73746F726167652D +66756C6C2D647572696E672D67616D65706C6179186C6576656C2D73746F726167652D636F7272 +757074696F6E1F65646974696F6E2D6D69736D617463682D76616E696C6C612D746F2D6564751F +65646974696F6E2D6D69736D617463682D6564752D746F2D76616E696C6C6121656469746F722D +6D69736D617463682D656469746F722D746F2D76616E696C6C6121656469746F722D6D69736D61 +7463682D76616E696C6C612D746F2D656469746F720B64656E792D6C69737465640D6E6F6E6365 +2D6D697373696E670F6E6F6E63652D6E6F742D666F756E640D6E6F6E63652D657870697265640F +6E6F6E63652D6E6F742D76616C696411686F73742D646973636F6E6E656374656421656469746F +722D6A6F696E2D696E74656E742D706F6C6963792D6661696C7572651F6E65746865722D6E6574 +2D6964656E746974792D6E6F742D616C6C6F7765640C696E76616C69642D6E616D650D65787069 +7265642D746F6B656E1C686F73742D616363657074732D6E6F2D747970652D6F662D617574681B +6E6F742D61757468656E746963617465642D666173742D6661696C12656469746F722D6E6F742D +616C6C6F776564040019626564726F636B2D646973636F6E6E6563742D726561736F6E03006801 +6D0308677261636566756C0F696D6D6564696174652D636C6F73650F64726F702D636F6E6E6563 +74696F6E040016736F636B65742D74656172646F776E2D706F6C69637903006A01720306726561 +736F6EC6000E6C6F672D746F2D636F6E736F6C657F0F74656172646F776E2D706F6C696379EB00 +0400116A6176612D6B69636B2D6F7074696F6E7303006C01720606726561736F6EE900076D6573 +73616765730C736B69702D6D6573736167657F1066696C74657265642D6D657373616765730E6C +6F672D746F2D636F6E736F6C657F0F74656172646F776E2D706F6C696379EB0004001462656472 +6F636B2D6B69636B2D6F7074696F6E7303006E016BC600016B7701720606726561736F6EF00006 +736F75726365CD000E657870697265732D61742D757463CD00106475726174696F6E2D7365636F +6E6473F1000E6B69636B2D69662D6F6E6C696E657F0E6C6F672D746F2D636F6E736F6C657F0400 +1262616E2D706C617965722D6F7074696F6E7303007201720606726561736F6EF00006736F7572 +6365CD000E657870697265732D61742D757463CD00106475726174696F6E2D7365636F6E6473F1 +00156B69636B2D6D61746368696E672D706C61796572737F0E6C6F672D746F2D636F6E736F6C65 +7F04000E62616E2D69702D6F7074696F6E73030074040006706C61796572030101720502696421 +0375726C7304686173687306666F726365647F0E70726F6D70742D6D657373616765F000040012 +6A6176612D7265736F757263652D7061636B03007701720A026964210776657273696F6E730473 +697A65770C646F776E6C6F61642D75726C730B636F6E74656E742D6B6579CD000D7375622D7061 +636B2D6E616D65CD000A636F6E74656E742D6964CD000B6861732D736372697074737F0A616464 +6F6E2D7061636B7F0B7274782D656E61626C65647F04001B626564726F636B2D7265736F757263 +652D7061636B2D656E747279030079016B210170FA000172070872657175697265647F0F686173 +2D6164646F6E2D7061636B737F0B6861732D736372697074737F2169732D76696272616E742D76 +697375616C732D666F7263652D64697361626C65647F11776F726C642D74656D706C6174652D69 +64FB0016776F726C642D74656D706C6174652D76657273696F6ECD00057061636B73FC0004001B +626564726F636B2D7265736F757263652D7061636B732D696E666F03007D04000B6A6176612D70 +6C61796572030104000E626564726F636B2D706C61796572030101687601690D0140010473656C +6681010082010400185B6D6574686F645D706C617965722E61732D656E74697479018301014001 +0473656C66810100210400155B6D6574686F645D706C617965722E6765742D6964018401014001 +0473656C66810100730400175B6D6574686F645D706C617965722E6765742D6E616D6501850101 +40010473656C668101000304001B5B6D6574686F645D706C617965722E6765742D706F73697469 +6F6E0186010140010473656C66810100760400165B6D6574686F645D706C617965722E6765742D +7961770187010400185B6D6574686F645D706C617965722E6765742D706974636801870101690B +0140010473656C6681010088010400185B6D6574686F645D706C617965722E6765742D776F726C +640189010140010473656C668101000504001B5B6D6574686F645D706C617965722E6765742D67 +616D656D6F6465018A010140020473656C668101046D6F646505007F04001B5B6D6574686F645D +706C617965722E7365742D67616D656D6F6465018B010400195B6D6574686F645D706C61796572 +2E6765742D6C6F63616C650185010140010473656C66810100790400175B6D6574686F645D706C +617965722E6765742D70696E67018C010140010473656C66810100130400235B6D6574686F645D +706C617965722E6765742D7065726D697373696F6E2D6C6576656C018D010140020473656C6681 +01056C6576656C1301000400235B6D6574686F645D706C617965722E7365742D7065726D697373 +696F6E2D6C6576656C018E010140030473656C668101046E6F6465730576616C75657F01000400 +1D5B6D6574686F645D706C617965722E7365742D7065726D697373696F6E018F01014002047365 +6C668101046E6F646573010004001F5B6D6574686F645D706C617965722E756E7365742D706572 +6D697373696F6E019001016B7F0140020473656C668101046E6F6465730091010400215B6D6574 +686F645D706C617965722E6861732D7065726D697373696F6E2D7365740192010140020473656C +668101046E6F646573007F04001D5B6D6574686F645D706C617965722E6861732D7065726D6973 +73696F6E0193010140010473656C66810100C60004001F5B6D6574686F645D706C617965722E67 +65742D646973706C61792D6E616D650194010140020473656C6681010C646973706C61792D6E61 +6D65C600010004001F5B6D6574686F645D706C617965722E7365742D646973706C61792D6E616D +650195010140010473656C66810100F0000400205B6D6574686F645D706C617965722E6765742D +7461622D6C6973742D6E616D650196010140020473656C668101046E616D65F00001000400205B +6D6574686F645D706C617965722E7365742D7461622D6C6973742D6E616D650197010140030473 +656C6681010474657874C600076F7665726C61797F01000400225B6D6574686F645D706C617965 +722E73656E642D73797374656D2D6D65737361676501980101707D0140020473656C6681010973 +69676E61747572659901010004002A5B6D6574686F645D706C617965722E64656C6574652D6D65 +73736167652D62792D7369676E6174757265019A010140020473656C6681010C7369676E617475 +72652D69647A01000400235B6D6574686F645D706C617965722E64656C6574652D6D6573736167 +652D62792D6964019B010140030473656C66810106686561646572C60006666F6F746572C60001 +000400295B6D6574686F645D706C617965722E7365742D7461622D6C6973742D6865616465722D +666F6F746572019C010140020473656C668101056F726465727A01000400215B6D6574686F645D +706C617965722E7365742D7461622D6C6973742D6F72646572019D010140020473656C66810107 +6C6174656E63797A01000400235B6D6574686F645D706C617965722E7365742D7461622D6C6973 +742D6C6174656E6379019E010140020473656C668101066C69737465647F01000400225B6D6574 +686F645D706C617965722E7365742D7461622D6C6973742D6C6973746564019F01014002047365 +6C6681010474657874C60001000400195B6D6574686F645D706C617965722E73686F772D746974 +6C6501A00104001C5B6D6574686F645D706C617965722E73686F772D7375627469746C6501A001 +04001D5B6D6574686F645D706C617965722E73686F772D616374696F6E62617201A00101400404 +73656C66810107666164652D696E7A04737461797A08666164652D6F75747A01000400235B6D65 +74686F645D706C617965722E73656E642D7469746C652D616E696D6174696F6E01A101016B8201 +0140020473656C66810106656E74697479A20101000400195B6D6574686F645D706C617965722E +7365742D63616D65726101A3010140020473656C66810109656E746974792D6964790100040023 +5B6D6574686F645D706C617965722E7365742D63616D6572612D656E746974792D696401A40104 +00235B6D6574686F645D706C617965722E6765742D63616D6572612D656E746974792D6964018C +010140010473656C668101010004001B5B6D6574686F645D706C617965722E72657365742D6361 +6D65726101A5010140050473656C66810105736F756E64370863617465676F72793906766F6C75 +6D65760570697463687601000400195B6D6574686F645D706C617965722E706C61792D736F756E +6401A6010140060473656C66810103706F730305736F756E64370863617465676F72793906766F +6C756D657605706974636876010004001C5B6D6574686F645D706C617965722E706C61792D736F +756E642D617401A701016B37016B390140030473656C66810105736F756E64A801086361746567 +6F7279A90101000400195B6D6574686F645D706C617965722E73746F702D736F756E6401AA0101 +40050473656C6681010A736F756E642D6E616D65730863617465676F72793906766F6C756D6576 +0570697463687601000400205B6D6574686F645D706C617965722E706C61792D637573746F6D2D +736F756E6401AB010140060473656C66810103706F73030A736F756E642D6E616D657308636174 +65676F72793906766F6C756D65760570697463687601000400235B6D6574686F645D706C617965 +722E706C61792D637573746F6D2D736F756E642D617401AC010140030473656C6681010A736F75 +6E642D6E616D65CD000863617465676F7279A90101000400205B6D6574686F645D706C61796572 +2E73746F702D637573746F6D2D736F756E6401AD010140060473656C668101087061727469636C +653B03706F730305636F756E7479066F666673657403096D61782D737065656476010004001E5B +6D6574686F645D706C617965722E737061776E2D7061727469636C657301AE010140030473656C +66810103706F730708626C6F636B2D69647B01000400205B6D6574686F645D706C617965722E73 +656E642D626C6F636B2D6368616E676501AF010140020473656C66810103706F73070100040021 +5B6D6574686F645D706C617965722E72657365742D626C6F636B2D6368616E676501B001014002 +0473656C668101037961777601000400225B6D6574686F645D706C617965722E73656E642D6875 +72742D616E696D6174696F6E01B1010140020473656C6681010468616E640101000400185B6D65 +74686F645D706C617965722E6F70656E2D626F6F6B01B2010140030473656C66810103706F7307 +0D69732D66726F6E742D746578747F010004001F5B6D6574686F645D706C617965722E6F70656E +2D7369676E2D656469746F7201B3010140020473656C6681010876656C6F636974790301000400 +1B5B6D6574686F645D706C617965722E7365742D76656C6F6369747901B4010140040473656C66 +810108737472656E67746875017875017A75010004001E5B6D6574686F645D706C617965722E61 +70706C792D6B6E6F636B6261636B01B5010140020473656C668101066C6F636B65647F01000400 +225B6D6574686F645D706C617965722E7365742D6D6F76656D656E742D6C6F636B656401B60101 +40010473656C668101007F0400215B6D6574686F645D706C617965722E69732D6D6F76656D656E +742D6C6F636B656401B7010140020473656C668101057469636B737A010004001F5B6D6574686F +645D706C617965722E7365742D667265657A652D7469636B7301B8010140010473656C66810100 +7A04001F5B6D6574686F645D706C617965722E6765742D667265657A652D7469636B7301B90101 +70CA000140020473656C668101056C696E6B73BA01010004001F5B6D6574686F645D706C617965 +722E7365742D7365727665722D6C696E6B7301BB01016B760140050473656C66810108706F7369 +74696F6E0303796177BC01057069746368BC0105776F726C64880101000400175B6D6574686F64 +5D706C617965722E74656C65706F727401BD010140050473656C66810109776F726C642D726566 +880108706F736974696F6E0303796177BC01057069746368BC01010004001D5B6D6574686F645D +706C617965722E74656C65706F72742D776F726C6401BE010400165B6D6574686F645D706C6179 +65722E7265737061776E01A5010169170140020473656C668101076775692D726566BF01010004 +00175B6D6574686F645D706C617965722E6F70656E2D67756901C0010140020473656C66810107 +6F7074696F6E73F30001000400125B6D6574686F645D706C617965722E62616E01C10101400204 +73656C668101076F7074696F6E73F50001000400155B6D6574686F645D706C617965722E62616E +2D697001C2010140030473656C66810104686F73747304706F72747B01000400175B6D6574686F +645D706C617965722E7472616E7366657201C3010140020473656C668101066566666563742501 +000400195B6D6574686F645D706C617965722E6164642D65666665637401C4010140020473656C +6681010665666665637423010004001C5B6D6574686F645D706C617965722E72656D6F76652D65 +666665637401C50104001C5B6D6574686F645D706C617965722E636C6561722D65666665637473 +01A5010140020473656C6681010665666665637423007F0400195B6D6574686F645D706C617965 +722E6861732D65666665637401C601016B250140020473656C668101066566666563742300C701 +0400195B6D6574686F645D706C617965722E6765742D65666665637401C8010170250140010473 +656C66810100C9010400215B6D6574686F645D706C617965722E6765742D6163746976652D6566 +666563747301CA010140020473656C66810106616D6F756E747601000400135B6D6574686F645D +706C617965722E6865616C01CB010140030473656C66810106616D6F756E74760B64616D616765 +2D747970652D01000400155B6D6574686F645D706C617965722E64616D61676501CC010400135B +6D6574686F645D706C617965722E6B696C6C01A5010140030473656C6681010863617465676F72 +792F07737461742D69647A007A04001C5B6D6574686F645D706C617965722E6765742D73746174 +697374696301CD010140040473656C6681010863617465676F72792F07737461742D69647A0576 +616C75657A010004001C5B6D6574686F645D706C617965722E7365742D73746174697374696301 +CE010140040473656C6681010863617465676F72792F07737461742D69647A06616D6F756E747A +01000400225B6D6574686F645D706C617965722E696E6372656D656E742D737461746973746963 +01CF010140020473656C668101047374617431007A0400235B6D6574686F645D706C617965722E +6765742D637573746F6D2D73746174697374696301D0010140030473656C668101047374617431 +0576616C75657A01000400235B6D6574686F645D706C617965722E7365742D637573746F6D2D73 +746174697374696301D1010140030473656C66810104737461743106616D6F756E747A01000400 +295B6D6574686F645D706C617965722E696E6372656D656E742D637573746F6D2D737461746973 +74696301D2010400195B6D6574686F645D706C617965722E73656E642D737461747301A5010140 +010473656C66810100CD000400175B6D6574686F645D706C617965722E6765742D7465616D01D3 +010140030473656C6681010567726F7570730E6475726174696F6E2D7469636B737A010004001D +5B6D6574686F645D706C617965722E73746172742D636F6F6C646F776E01D4010140020473656C +6681010567726F757073007604001B5B6D6574686F645D706C617965722E6765742D636F6F6C64 +6F776E01D5010140020473656C6681010567726F757073007F04001D5B6D6574686F645D706C61 +7965722E69732D6F6E2D636F6F6C646F776E01D6010140020473656C66810107616C6C6F776564 +7F010004001F5B6D6574686F645D706C617965722E7365742D616C6C6F772D666C6967687401D7 +010140020473656C66810105737065656476010004001C5B6D6574686F645D706C617965722E73 +65742D666C792D737065656401D80104001D5B6D6574686F645D706C617965722E7365742D7761 +6C6B2D737065656401D8010140020473656C6681010C696E76756C6E657261626C657F01000400 +1F5B6D6574686F645D706C617965722E7365742D696E76756C6E657261626C6501D90101693501 +40010473656C66810100DA0104001C5B6D6574686F645D706C617965722E6765742D696E76656E +746F727901DB010169330140010473656C66810100DC0104001E5B6D6574686F645D706C617965 +722E6765742D656E6465722D636865737401DD010140010473656C668101007D0400205B6D6574 +686F645D706C617965722E6765742D73656C65637465642D736C6F7401DE01016909016BDF0101 +40020473656C6681010468616E640100E00104001F5B6D6574686F645D706C617965722E676574 +2D6974656D2D696E2D68616E6401E1010140020473656C66810104736C6F747D00E0010400215B +6D6574686F645D706C617965722E6765742D696E76656E746F72792D6974656D01E20101400304 +73656C6681010468616E640105737461636BE001010004001F5B6D6574686F645D706C61796572 +2E7365742D6974656D2D696E2D68616E6401E3010140030473656C66810104736C6F747D057374 +61636BE00101000400215B6D6574686F645D706C617965722E7365742D696E76656E746F72792D +6974656D01E4010400235B6D6574686F645D706C617965722E6765742D656E6465722D63686573 +742D6974656D01E2010400235B6D6574686F645D706C617965722E7365742D656E6465722D6368 +6573742D6974656D01E4010400205B6D6574686F645D706C617965722E636C6561722D656E6465 +722D636865737401A50104001F5B6D6574686F645D706C617965722E6F70656E2D656E6465722D +636865737401A5010400195B6D6574686F645D706C617965722E6765742D6865616C7468018701 +0140020473656C668101066865616C74687601000400195B6D6574686F645D706C617965722E73 +65742D6865616C746801E50104001D5B6D6574686F645D706C617965722E6765742D6D61782D68 +65616C74680187010140020473656C6681010A6D61782D6865616C746876010004001D5B6D6574 +686F645D706C617965722E7365742D6D61782D6865616C746801E60104001D5B6D6574686F645D +706C617965722E6765742D666F6F642D6C6576656C01DE010140020473656C6681010A666F6F64 +2D6C6576656C7D010004001D5B6D6574686F645D706C617965722E7365742D666F6F642D6C6576 +656C01E70104001D5B6D6574686F645D706C617965722E6765742D73617475726174696F6E0187 +010140020473656C6681010A73617475726174696F6E76010004001D5B6D6574686F645D706C61 +7965722E7365742D73617475726174696F6E01E80104001D5B6D6574686F645D706C617965722E +6765742D65786861757374696F6E0187010140020473656C6681010A65786861757374696F6E76 +010004001D5B6D6574686F645D706C617965722E7365742D65786861757374696F6E01E9010400 +1D5B6D6574686F645D706C617965722E6765742D6162736F727074696F6E018701014002047365 +6C6681010A6162736F727074696F6E76010004001D5B6D6574686F645D706C617965722E736574 +2D6162736F727074696F6E01EA010400235B6D6574686F645D706C617965722E6765742D657870 +657269656E63652D6C6576656C01B9010400265B6D6574686F645D706C617965722E6765742D65 +7870657269656E63652D70726F67726573730187010400245B6D6574686F645D706C617965722E +6765742D657870657269656E63652D706F696E747301B9010140020473656C668101056C657665 +6C7A01000400235B6D6574686F645D706C617965722E7365742D657870657269656E63652D6C65 +76656C01EB010140020473656C6681010870726F67726573737601000400265B6D6574686F645D +706C617965722E7365742D657870657269656E63652D70726F677265737301EC01014002047365 +6C66810106706F696E74737A01000400245B6D6574686F645D706C617965722E7365742D657870 +657269656E63652D706F696E747301ED010140020473656C668101066C6576656C737A01000400 +245B6D6574686F645D706C617965722E6164642D657870657269656E63652D6C6576656C7301EE +010400245B6D6574686F645D706C617965722E6164642D657870657269656E63652D706F696E74 +7301ED010400185B6D6574686F645D706C617965722E69732D666C79696E6701B7010140020473 +656C66810106666C79696E677F01000400195B6D6574686F645D706C617965722E7365742D666C +79696E6701EF010140010473656C66810100CC0004001C5B6D6574686F645D706C617965722E67 +65742D6162696C697469657301F0010140020473656C668101096162696C6974696573CC000100 +04001C5B6D6574686F645D706C617965722E7365742D6162696C697469657301F1010400155B6D +6574686F645D706C617965722E6765742D6970018501016BCF000140010473656C66810100F201 +0400175B6D6574686F645D706C617965722E6765742D736B696E01F3010140020473656C668101 +04736B696ECF0001000400175B6D6574686F645D706C617965722E7365742D736B696E01F40101 +40010473656C66810100D10004001D5B6D6574686F645D706C617965722E6765742D736B696E2D +706172747301F5010140020473656C668101057061727473D100010004001D5B6D6574686F645D +706C617965722E7365742D736B696E2D706172747301F6010140030473656C6681010474696D65 +770872656C61746976657F010004001E5B6D6574686F645D706C617965722E7365742D706C6179 +65722D74696D6501F7010400205B6D6574686F645D706C617965722E72657365742D706C617965 +722D74696D6501A5010140010473656C66810100F10004001E5B6D6574686F645D706C61796572 +2E6765742D706C617965722D74696D6501F8010400265B6D6574686F645D706C617965722E6973 +2D706C617965722D74696D652D72656C617469766501B7010140020473656C6681010777656174 +6865723F01000400215B6D6574686F645D706C617965722E7365742D706C617965722D77656174 +68657201F9010400235B6D6574686F645D706C617965722E72657365742D706C617965722D7765 +617468657201A501016B3F0140010473656C66810100FA010400215B6D6574686F645D706C6179 +65722E6765742D706C617965722D7765617468657201FB010140020473656C66810103706F7303 +01000400215B6D6574686F645D706C617965722E7365742D636F6D706173732D74617267657401 +FC010400215B6D6574686F645D706C617965722E6765742D636F6D706173732D74617267657401 +86010400235B6D6574686F645D706C617965722E7365742D7265737061776E2D6C6F636174696F +6E01FC01016B030140010473656C66810100FD010400235B6D6574686F645D706C617965722E67 +65742D7265737061776E2D6C6F636174696F6E01FE010169760140020473656C668101056F7468 +6572FF01010004001A5B6D6574686F645D706C617965722E686964652D706C6179657201800204 +001A5B6D6574686F645D706C617965722E73686F772D706C617965720180020140020473656C66 +8101056F74686572FF01007F0400165B6D6574686F645D706C617965722E63616E2D7365650181 +0204001D5B6D6574686F645D706C617965722E63616E2D7365652D706C61796572018102014002 +0473656C6681010A6C6174656E63792D6D737A01000400205B6D6574686F645D706C617965722E +7365742D7461622D6C6973742D70696E670182020140030473656C668101076974656D2D696473 +057469636B737A01000400205B6D6574686F645D706C617965722E7365742D6974656D2D636F6F +6C646F776E018302016B7A0140020473656C668101076974656D2D6964730084020400205B6D65 +74686F645D706C617965722E6765742D6974656D2D636F6F6C646F776E0185020140020473656C +668101076974656D2D696473007F0400205B6D6574686F645D706C617965722E6861732D697465 +6D2D636F6F6C646F776E018602016B0F0140030473656C6681010C6D61782D64697374616E6365 +750E696E636C7564652D666C756964737F00870204001E5B6D6574686F645D706C617965722E72 +61792D74726163652D626C6F636B018802016B110140020473656C6681010C6D61782D64697374 +616E63657500890204001F5B6D6574686F645D706C617965722E7261792D74726163652D656E74 +697479018A020140020473656C6681010C6D61782D64697374616E63657500A2010400205B6D65 +74686F645D706C617965722E6765742D7461726765742D656E74697479018B020140020473656C +6681010C6D61782D64697374616E63657900FD0104001F5B6D6574686F645D706C617965722E67 +65742D7461726765742D626C6F636B018C020400255B6D6574686F645D706C617965722E676574 +2D7461726765742D626C6F636B2D65786163740188020140020473656C6681010474797065C100 +00A2010400205B6D6574686F645D706C617965722E6C61756E63682D70726F6A656374696C6501 +8D02016B2B0140020473656C6681010E616476616E63656D656E742D696473008E020400275B6D +6574686F645D706C617965722E6765742D616476616E63656D656E742D70726F6772657373018F +020140030473656C6681010E616476616E63656D656E742D69647309637269746572696F6E7300 +7F04002A5B6D6574686F645D706C617965722E61776172642D616476616E63656D656E742D6372 +69746572696F6E01900204002B5B6D6574686F645D706C617965722E7265766F6B652D61647661 +6E63656D656E742D637269746572696F6E0190020140020473656C6681010E616476616E63656D +656E742D696473007F0400205B6D6574686F645D706C617965722E61776172642D616476616E63 +656D656E740191020400215B6D6574686F645D706C617965722E7265766F6B652D616476616E63 +656D656E7401910204001E5B6D6574686F645D706C617965722E6861732D616476616E63656D65 +6E740191020170730140010473656C6681010092020400295B6D6574686F645D706C617965722E +6765742D636F6D706C657465642D616476616E63656D656E747301930204002B5B6D6574686F64 +5D706C617965722E6765742D73656C65637465642D616476616E63656D656E742D74616201D301 +0140020473656C668101067461622D6964CD00010004002B5B6D6574686F645D706C617965722E +7365742D73656C65637465642D616476616E63656D656E742D74616201940201697F016B950201 +40010473656C6681010096020400165B6D6574686F645D706C617965722E61732D6A6176610197 +0201698001016B98020140010473656C6681010099020400195B6D6574686F645D706C61796572 +2E61732D626564726F636B019A0201687F0140010473656C669B0200D70004001F5B6D6574686F +645D6A6176612D706C617965722E6765742D76657273696F6E019C020140010473656C669B0200 +7304001D5B6D6574686F645D6A6176612D706C617965722E6765742D6272616E64019D02040026 +5B6D6574686F645D6A6176612D706C617965722E6765742D7365727665722D6164647265737301 +9D020140010473656C669B0200DD000400205B6D6574686F645D6A6176612D706C617965722E67 +65742D73657474696E6773019E020140020473656C669B02067061636B65741D010004001F5B6D +6574686F645D6A6176612D706C617965722E73656E642D7061636B6574019F020140030473656C +669B02076368616E6E656C730464617461990101000400275B6D6574686F645D6A6176612D706C +617965722E73656E642D637573746F6D2D7061796C6F616401A0020140020473656C669B020664 +69616C6F671B010004001F5B6D6574686F645D6A6176612D706C617965722E73686F772D646961 +6C6F6701A1020140010473656C669B0201000400205B6D6574686F645D6A6176612D706C617965 +722E636C6561722D6469616C6F6701A2020169270140010473656C669B0200A3020400225B6D65 +74686F645D6A6176612D706C617965722E6765742D73636F7265626F61726401A4020400245B6D +6574686F645D6A6176612D706C617965722E72657365742D73636F7265626F61726401A2020140 +020473656C669B02047061636BF80001000400265B6D6574686F645D6A6176612D706C61796572 +2E73656E642D7265736F757263652D7061636B01A5020140020473656C669B0202696421010004 +00285B6D6574686F645D6A6176612D706C617965722E72656D6F76652D7265736F757263652D70 +61636B01A6020400285B6D6574686F645D6A6176612D706C617965722E636C6561722D7265736F +757263652D7061636B7301A2020140020473656C669B02076F7074696F6E73ED0001000400185B +6D6574686F645D6A6176612D706C617965722E6B69636B01A7020140030473656C669B02056576 +656E74C3000576616C75657601000400235B6D6574686F645D6A6176612D706C617965722E7365 +6E642D67616D652D6576656E7401A8020140030473656C669B0209656E746974792D69647A0673 +74617475733D01000400265B6D6574686F645D6A6176612D706C617965722E73656E642D656E74 +6974792D73746174757301A902016880010140010473656C66AA0200D9000400225B6D6574686F +645D626564726F636B2D706C617965722E6765742D76657273696F6E01AB020140010473656C66 +AA0200E7000400235B6D6574686F645D626564726F636B2D706C617965722E6765742D73657474 +696E677301AC020140020473656C66AA02076162696C697479D300007F0400225B6D6574686F64 +5D626564726F636B2D706C617965722E6765742D6162696C69747901AD020140030473656C66AA +02076162696C697479D3000576616C75657F01000400225B6D6574686F645D626564726F636B2D +706C617965722E7365742D6162696C69747901AE020140020473656C66AA0204666C6167D50000 +7F0400265B6D6574686F645D626564726F636B2D706C617965722E6765742D7374617475732D66 +6C616701AF020140030473656C66AA0204666C6167D5000576616C75657F01000400265B6D6574 +686F645D626564726F636B2D706C617965722E7365742D7374617475732D666C616701B0020140 +020473656C66AA02067061636B65741F01000400225B6D6574686F645D626564726F636B2D706C +617965722E73656E642D7061636B657401B1020140020473656C66AA0204666F726D1900790400 +205B6D6574686F645D626564726F636B2D706C617965722E6F70656E2D666F726D01B202016929 +0140010473656C66AA0200B3020400255B6D6574686F645D626564726F636B2D706C617965722E +6765742D73636F7265626F61726401B4020140010473656C66AA0201000400275B6D6574686F64 +5D626564726F636B2D706C617965722E72657365742D73636F7265626F61726401B50201400204 +73656C66AA0204696E666FFE00010004002F5B6D6574686F645D626564726F636B2D706C617965 +722E73656E642D7265736F757263652D7061636B732D696E666F01B6020140020473656C66AA02 +076F7074696F6E73EF00010004001B5B6D6574686F645D626564726F636B2D706C617965722E6B +69636B01B7020170FF0101400109776F726C642D726566880100B8020400116765742D776F726C +642D706C617965727301B90203001B70756D706B696E3A706C7567696E2F706C6179657240302E +312E30055201421E020302011404000A6974656D2D737461636B030000016D06086275696C6469 +6E670872656473746F6E650965717569706D656E74046D69736304666F6F6406626C6F636B7304 +000F7265636970652D63617465676F7279030002017073017103046974656D0173000374616701 +7300066F6E652D6F6601040004000A696E6772656469656E74030005016F027306017007016901 +016B73016B03016B7F017206077061747465726E04036B657908066F7574707574090567726F75 +700A0863617465676F72790B1173686F772D6E6F74696669636174696F6E0C04000D7368617065 +642D72656369706503000D0170060172040B696E6772656469656E74730F066F75747075740905 +67726F75700A0863617465676F72790B04001073686170656C6573732D72656369706503001001 +72060A696E6772656469656E7406066F7574707574090A657870657269656E6365760C636F6F6B +696E672D74696D65790567726F75700A0863617465676F72790B04000E636F6F6B696E672D7265 +63697065030012016D0408736D656C74696E6708626C617374696E6707736D6F6B696E67086361 +6D706669726504000C636F6F6B696E672D7479706503001404000E7265636970652D6D616E6167 +657203010168160140030473656C661702696473067265636970650E01000400265B6D6574686F +645D7265636970652D6D616E616765722E72656769737465722D73686170656401180140030473 +656C661702696473067265636970651101000400295B6D6574686F645D7265636970652D6D616E +616765722E72656769737465722D73686170656C65737301190140040473656C6617026964730C +73746174696F6E2D7479706515067265636970651301000400275B6D6574686F645D7265636970 +652D6D616E616765722E72656769737465722D636F6F6B696E67011A03001B70756D706B696E3A +706C7567696E2F72656369706540302E312E30055301421A01720702696473046E616D65730B64 +65736372697074696F6E730B7061636B2D666F726D6174790A69732D656E61626C65647F0C7265 +636970652D636F756E74790E66756E6374696F6E2D636F756E747904000D646174617061636B2D +696E666F0300000171040566697273740000046C6173740000066265666F726501730005616674 +657201730004000F656E61626C652D706F736974696F6E030002040010646174617061636B2D6D +616E6167657203010168040170010140010473656C660500060400275B6D6574686F645D646174 +617061636B2D6D616E616765722E6C6973742D616C6C2D7061636B73010704002B5B6D6574686F +645D646174617061636B2D6D616E616765722E6C6973742D656E61626C65642D7061636B730107 +04002D5B6D6574686F645D646174617061636B2D6D616E616765722E6C6973742D617661696C61 +626C652D7061636B730107016B010140020473656C6605046E616D657300080400215B6D657468 +6F645D646174617061636B2D6D616E616765722E6765742D7061636B01090140020473656C6605 +046E616D6573007F0400235B6D6574686F645D646174617061636B2D6D616E616765722E69732D +656E61626C6564010A016A0001730140030473656C6605046E616D657308706F736974696F6E03 +000B0400245B6D6574686F645D646174617061636B2D6D616E616765722E656E61626C652D7061 +636B010C0140020473656C6605046E616D6573000B0400255B6D6574686F645D64617461706163 +6B2D6D616E616765722E64697361626C652D7061636B010D0140010473656C6605000B04001F5B +6D6574686F645D646174617061636B2D6D616E616765722E72656C6F6164010E016A0179017301 +40020473656C6605046E616D6573000F0400295B6D6574686F645D646174617061636B2D6D616E +616765722E657865637574652D66756E6374696F6E011003001D70756D706B696E3A706C756769 +6E2F646174617061636B40302E312E3005540203001D06706C617965720203001D1262616E2D70 +6C617965722D6F7074696F6E730203001D0E62616E2D69702D6F7074696F6E730203001D0B7365 +727665722D6C696E6B0203001D116B6E6F776E2D7365727665722D6C696E6B0203001D11736572 +7665722D6C696E6B2D6C6162656C0203001E0E7265636970652D6D616E61676572020300051365 +6E6368616E746D656E742D6D616E616765720203000512637573746F6D2D656E6368616E746D65 +6E740203001A10616476616E63656D656E742D696E666F0203001F10646174617061636B2D6D61 +6E616765720203001F0D646174617061636B2D696E666F0142CB010203020155040006706C6179 +6572030000020302015604001262616E2D706C617965722D6F7074696F6E730300020203020157 +04000E62616E2D69702D6F7074696F6E73030004020302015804000B7365727665722D6C696E6B +03000602030201590400116B6E6F776E2D7365727665722D6C696E6B030008020302015A040011 +7365727665722D6C696E6B2D6C6162656C03000A020302013F04000967616D652D6D6F64650300 +0C0203020140040005776F726C6403000E020302010804000E746578742D636F6D706F6E656E74 +030010020302013404000475756964030012020302015B04000E7265636970652D6D616E616765 +72030014020302015C040013656E6368616E746D656E742D6D616E61676572030016020302015D +040012637573746F6D2D656E6368616E746D656E7403001802030201440400107065726D697373 +696F6E2D6C6576656C03001A020302015E040010616476616E63656D656E742D696E666F03001C +020302015F040010646174617061636B2D6D616E6167657203001E020302016004000D64617461 +7061636B2D696E666F030020017204047575696413046E616D6573056C6576656C1B1562797061 +737365732D706C617965722D6C696D69747F0400086F702D656E74727903002204000A6F702D6D +616E616765720301016B73017206047575696413046E616D657307637265617465647306736F75 +7263657307657870697265732506726561736F6E7304001362616E6E65642D706C617965722D65 +6E7472790300260172050269707307637265617465647306736F75726365730765787069726573 +2506726561736F6E7304000F62616E6E65642D69702D656E74727903002804000B62616E2D6D61 +6E616765720301017202047575696413046E616D657304000F77686974656C6973742D656E7472 +7903002B04001177686974656C6973742D6D616E616765720301016D0408706561636566756C04 +65617379066E6F726D616C046861726404000A646966666963756C747903002E016D03096F7665 +72776F726C64066E657468657203656E6404000964696D656E73696F6E030030016B79016B7701 +7206096370752D636F756E74320C746F74616C2D6D656D6F7279330B757365642D6D656D6F7279 +33076F732D6E616D65250A6F732D76657273696F6E250F70756D706B696E2D76657273696F6E73 +0400087379732D696E666F03003401690101710207636F6E736F6C65000006706C617965720136 +0004000E636F6D6D616E642D73656E646572030037040006736572766572030101682401400204 +73656C663A02696413007F0400185B6D6574686F645D6F702D6D616E616765722E69732D6F7001 +3B016B230140020473656C663A02696413003C0400195B6D6574686F645D6F702D6D616E616765 +722E6765742D6F70013D0140020473656C663A02696413001B0400275B6D6574686F645D6F702D +6D616E616765722E6765742D7065726D697373696F6E2D6C6576656C013E0140050473656C663A +046E616D657302696413056C6576656C1B1562797061737365732D706C617965722D6C696D6974 +7F010004001C5B6D6574686F645D6F702D6D616E616765722E6F702D706C61796572013F04001E +5B6D6574686F645D6F702D6D616E616765722E64656F702D706C61796572013B01702301400104 +73656C663A00C00004001B5B6D6574686F645D6F702D6D616E616765722E6C6973742D6F707301 +4101682A0140020473656C66C20002696413007F0400245B6D6574686F645D62616E2D6D616E61 +6765722E69732D706C617965722D62616E6E65640143016B270140020473656C66C20002696413 +00C4000400225B6D6574686F645D62616E2D6D616E616765722E6765742D706C617965722D6261 +6E01450140040473656C66C200046E616D657302696413076F7074696F6E7303010004001E5B6D +6574686F645D62616E2D6D616E616765722E62616E2D706C6179657201460400205B6D6574686F +645D62616E2D6D616E616765722E756E62616E2D706C6179657201430170270140010473656C66 +C20000C7000400245B6D6574686F645D62616E2D6D616E616765722E6C6973742D706C61796572 +2D62616E7301480140020473656C66C20002697073007F0400205B6D6574686F645D62616E2D6D +616E616765722E69732D69702D62616E6E65640149016B290140020473656C66C2000269707300 +CA0004001E5B6D6574686F645D62616E2D6D616E616765722E6765742D69702D62616E014B0140 +030473656C66C20002697073076F7074696F6E7305010004001A5B6D6574686F645D62616E2D6D +616E616765722E62616E2D6970014C04001C5B6D6574686F645D62616E2D6D616E616765722E75 +6E62616E2D697001490170290140010473656C66C20000CD000400205B6D6574686F645D62616E +2D6D616E616765722E6C6973742D69702D62616E73014E01682D0140010473656C66CF00007F04 +00245B6D6574686F645D77686974656C6973742D6D616E616765722E69732D656E61626C656401 +500140020473656C66CF0007656E61626C65647F01000400255B6D6574686F645D77686974656C +6973742D6D616E616765722E7365742D656E61626C656401510140020473656C66CF0002696413 +007F0400285B6D6574686F645D77686974656C6973742D6D616E616765722E69732D7768697465 +6C697374656401520140030473656C66CF00046E616D657302696413007F0400245B6D6574686F +645D77686974656C6973742D6D616E616765722E6164642D706C6179657201530400275B6D6574 +686F645D77686974656C6973742D6D616E616765722E72656D6F76652D706C6179657201520170 +2C0140010473656C66CF0000D4000400265B6D6574686F645D77686974656C6973742D6D616E61 +6765722E6C6973742D656E747269657301550168390140010473656C66D600003504001B5B6D65 +74686F645D7365727665722E6765742D7379732D696E666F01570140010473656C66D600002F04 +001D5B6D6574686F645D7365727665722E6765742D646966666963756C74790158014001047365 +6C66D600007904001F5B6D6574686F645D7365727665722E6765742D706C617965722D636F756E +7401590140010473656C66D60000750400175B6D6574686F645D7365727665722E6765742D6D73 +7074015A0400165B6D6574686F645D7365727665722E6765742D747073015A0170360140010473 +656C66D60000DB0004001E5B6D6574686F645D7365727665722E6765742D616C6C2D706C617965 +7273015C016B360140020473656C66D600046E616D657300DD000400215B6D6574686F645D7365 +727665722E6765742D706C617965722D62792D6E616D65015E0140020473656C66D60002696413 +00DD000400215B6D6574686F645D7365727665722E6765742D706C617965722D62792D75756964 +015F01690F0170E0000140010473656C66D60000E10004001D5B6D6574686F645D736572766572 +2E6765742D616C6C2D776F726C64730162016BE0000140020473656C66D600046E616D657300E3 +000400205B6D6574686F645D7365727665722E6765742D776F726C642D62792D6E616D65016401 +40020473656C66D600046E616D6573007F0400185B6D6574686F645D7365727665722E6861732D +776F726C6401650140030473656C66D60007636F6D6D616E64730673656E64657238010004001E +5B6D6574686F645D7365727665722E657865637574652D636F6D6D616E6401660140030473656C +66D600046E616D65730964696D656E73696F6E3100E00004001B5B6D6574686F645D7365727665 +722E6372656174652D776F726C640167016A0001730140020473656C66D600046E616D657300E8 +0004001B5B6D6574686F645D7365727665722E756E6C6F61642D776F726C640169014001047365 +6C66D60000E8000400175B6D6574686F645D7365727665722E736176652D616C6C016A01400204 +73656C66D60009776F726C642D726566E00000DB000400235B6D6574686F645D7365727665722E +6765742D706C61796572732D696E2D776F726C64016B0140020473656C66D60009776F726C642D +726566E00000790400285B6D6574686F645D7365727665722E6765742D706C617965722D636F75 +6E742D696E2D776F726C64016C0140020473656C66D600076D6573736167657301000400185B6D +6574686F645D7365727665722E62726F616463617374016D01707D0140020473656C66D6000973 +69676E6174757265EE00010004002A5B6D6574686F645D7365727665722E64656C6574652D6D65 +73736167652D62792D7369676E6174757265016F0140020473656C66D6000C7369676E61747572 +652D69647A01000400235B6D6574686F645D7365727665722E64656C6574652D6D657373616765 +2D62792D696401700169110140030473656C66D60006686561646572F10006666F6F746572F100 +010004002F5B6D6574686F645D7365727665722E62726F6164636173742D7461622D6C6973742D +6865616465722D666F6F746572017204001E5B6D6574686F645D7365727665722E6765742D6D61 +782D706C617965727301590140010473656C66D600007F04001A5B6D6574686F645D7365727665 +722E69732D68617264636F7265017304001D5B6D6574686F645D7365727665722E69732D6F6E6C +696E652D6D6F646501730140010473656C66D60000730400175B6D6574686F645D736572766572 +2E6765742D6D6F7464017404001C5B6D6574686F645D7365727665722E6861732D77686974656C +697374017304001F5B6D6574686F645D7365727665722E6765742D616C6C6F772D6E6574686572 +017304001C5B6D6574686F645D7365727665722E6765742D616C6C6F772D656E64017301400104 +73656C66D600007D0400205B6D6574686F645D7365727665722E6765742D766965772D64697374 +616E636501750400265B6D6574686F645D7365727665722E6765742D73696D756C6174696F6E2D +64697374616E636501750140010473656C66D600000D0400235B6D6574686F645D736572766572 +2E6765742D64656661756C742D67616D656D6F646501760169150140010473656C66D60000F700 +0400215B6D6574686F645D7365727665722E6765742D7265636970652D6D616E61676572017801 +69240140010473656C66D60000F90004001D5B6D6574686F645D7365727665722E6765742D6F70 +2D6D616E61676572017A01692A0140010473656C66D60000FB0004001E5B6D6574686F645D7365 +727665722E6765742D62616E2D6D616E61676572017C01692D0140010473656C66D60000FD0004 +00245B6D6574686F645D7365727665722E6765742D77686974656C6973742D6D616E6167657201 +7E016B1D0140020473656C66D6000269647300FF0004001E5B6D6574686F645D7365727665722E +6765742D616476616E63656D656E740180010170730140010473656C66D6000081010400265B6D +6574686F645D7365727665722E6765742D616C6C2D616476616E63656D656E742D696473018201 +0169170140010473656C66D6000083010400265B6D6574686F645D7365727665722E6765742D65 +6E6368616E746D656E742D6D616E61676572018401016B190140020473656C66D6000269647300 +850104001E5B6D6574686F645D7365727665722E6765742D656E6368616E746D656E7401860104 +00265B6D6574686F645D7365727665722E6765742D616C6C2D656E6368616E746D656E742D6964 +7301820101691F0140010473656C66D6000087010400235B6D6574686F645D7365727665722E67 +65742D646174617061636B2D6D616E616765720188010170070140020473656C66D600056C696E +6B738901010004001F5B6D6574686F645D7365727665722E7365742D7365727665722D6C696E6B +73018A0103001B70756D706B696E3A706C7567696E2F73657276657240302E312E300561020300 +01066C6F63616C650203002006736572766572020300200A646966666963756C747901428F0102 +03020140040005776F726C640300000203020141040006656E7469747903000202030201550400 +06706C617965720300040203020128040014636F6D6D616E642D626C6F636B2D656E7469747903 +00060203020125040008706F736974696F6E030008020302011C040009626C6F636B2D706F7303 +000A02030201620400066C6F63616C6503000C020302013F04000967616D652D6D6F646503000E +020302011404000A6974656D2D737461636B030010020302016304000673657276657203001202 +0302016404000A646966666963756C7479030014020302010804000E746578742D636F6D706F6E +656E74030016016B7301691701710413696E76616C69642D636F6E73756D7074696F6E01180013 +696E76616C69642D726571756972656D656E740000117065726D697373696F6E2D64656E696564 +00000E636F6D6D616E642D6661696C656401190004000D636F6D6D616E642D6572726F7203001A +04000C636F6D6D616E642D6E6F6465030101720405696E7075747306637572736F727905737461 +7274790972656D61696E696E677304001273756767657374696F6E2D7265717565737403001D01 +6B190172020576616C75657307746F6F6C7469701F040012636F6D6D616E642D73756767657374 +696F6E03002001702101720305737461727479066C656E677468790676616C7565732204001363 +6F6D6D616E642D73756767657374696F6E730300230172020673696E676C657F0C706C61796572 +732D6F6E6C797F04000F656E746974792D617267756D656E74030025016905016907016901016F +0228290171050472636F6E000007636F6E736F6C65000006706C617965720127000D636F6D6D61 +6E642D626C6F636B012A000564756D6D790000040013636F6D6D616E642D73656E6465722D7479 +706503002B016D05047A65726F036F6E650374776F05746872656504666F75720400107065726D +697373696F6E2D6C6576656C03002D04000E636F6D6D616E642D73656E6465720301016D030B73 +696E676C652D776F72640871756F7461626C650667726565647904000B737472696E672D747970 +65030030016B76016F023232016B75016F023434016B7A016F023636016B78016F023838017135 +04626F6F6C000005666C6F617401330006646F75626C6501350007696E7465676572013700046C +6F6E6701390006737472696E6701310008656E746974696573000006656E74697479000007706C +617965727300000C67616D652D70726F66696C65000009626C6F636B2D706F7300000A636F6C75 +6D6E2D706F7300000A706F736974696F6E336400000A706F736974696F6E326400000B626C6F63 +6B2D737461746500000F626C6F636B2D7072656469636174650000046974656D00000E6974656D +2D707265646963617465000005636F6C6F72000009636F6D706F6E656E740000057374796C6500 +00076D6573736167650000106E62742D636F6D706F756E642D7461670000076E62742D74616700 +00086E62742D706174680000096F626A6563746976650000126F626A6563746976652D63726974 +657269610000096F7065726174696F6E0000087061727469636C65000005616E676C6500000872 +6F746174696F6E00000F73636F7265626F6172642D736C6F7400000C73636F72652D686F6C6465 +72017F00077377697A7A6C650000047465616D0000096974656D2D736C6F740000117265736F75 +7263652D6C6F636174696F6E00000A6D6F622D65666665637400000866756E6374696F6E00000D +656E746974792D616E63686F72000009696E742D72616E676500000B666C6F61742D72616E6765 +00000964696D656E73696F6E00000867616D656D6F646500000A646966666963756C7479000004 +74696D65013600087265736F757263650173000F7265736F757263652D6F722D74616701730013 +7265736F757263652D6F722D7461672D6B65790173000C7265736F757263652D6B65790173000F +74656D706C6174652D6D6972726F7200001174656D706C6174652D726F746174696F6E00000475 +756964000004000D617267756D656E742D7479706503003A016D050A61736B2D7365727665720B +616C6C2D7265636970657310617661696C61626C652D736F756E647310617661696C61626C652D +62696F6D65731373756D6D6F6E61626C652D656E74697469657304000F73756767657374696F6E +2D7479706503003C016D070470696E6B04626C75650372656405677265656E0679656C6C6F7706 +707572706C6505776869746504000D626F73736261722D636F6C6F7203003E016D050B6E6F2D64 +69766973696F6E086E6F746368657336096E6F74636865733130096E6F74636865733132096E6F +7463686573323004000D626F73736261722D7374796C65030040016D0A066D6173746572056D75 +736963077265636F726473077765617468657206626C6F636B7307686F7374696C65076E657574 +72616C07706C617965727307616D6269656E7405766F69636504000E736F756E642D6361746567 +6F7279030042016D020465796573046665657404000D656E746974792D616E63686F7203004401 +710407666C6F6174363401750007666C6F6174333201760005696E743332017A0005696E743634 +0178000400066E756D626572030046016F02C700C7000171020B6C6F7765722D626F756E6401C8 +00000B75707065722D626F756E6401C8000004000D6E6F742D696E2D626F756E6473030049016A +01C70001CA00016F03757575016F027575016F04767F767F01702701711B0673696D706C650173 +00036D736701730004626F6F6C017F00046974656D0173000E6974656D2D707265646963617465 +017300117265736F757263652D6C6F636174696F6E01730005626C6F636B0173000F626C6F636B +2D7072656469636174650173000474696D65017A00036E756D01CB000009626C6F636B2D706F73 +010B0005706F73336401CC000005706F73326401CD000008726F746174696F6E01CE0000086761 +6D656D6F6465010F000A646966666963756C747901150007706C617965727301CF000008706172 +7469636C650173000E746578742D636F6D706F6E656E740119000D626F73736261722D636F6C6F +72013F000D626F73736261722D7374796C6501C100000E736F756E642D63617465676F727901C3 +00000B64616D6167652D74797065017300066566666563740173000B656E6368616E746D656E74 +0173000B616476616E63656D656E740173000D656E746974792D616E63686F7201C50000040003 +61726703005004000D636F6E73756D65642D617267730301040007636F6D6D616E64030101691C +014001046E616D657300D40004001C5B7374617469635D636F6D6D616E642D6E6F64652E6C6974 +6572616C0155014002046E616D657304747970653B00D40004001D5B7374617469635D636F6D6D +616E642D6E6F64652E617267756D656E74015601681C0140020473656C66D700046E6F6465D400 +01000400195B6D6574686F645D636F6D6D616E642D6E6F64652E7468656E01580140020473656C +66D7000A68616E646C65722D696479010004002C5B6D6574686F645D636F6D6D616E642D6E6F64 +652E657865637574652D776974682D68616E646C65722D6964015904002C5B6D6574686F645D63 +6F6D6D616E642D6E6F64652E737567676573742D776974682D68616E646C65722D696401590400 +2C5B6D6574686F645D636F6D6D616E642D6E6F64652E726571756972652D776974682D68616E64 +6C65722D6964015901682F0140010473656C66DA00002C04002E5B6D6574686F645D636F6D6D61 +6E642D73656E6465722E6765742D636F6D6D616E642D73656E6465722D74797065015B01400104 +73656C66DA00007304001F5B6D6574686F645D636F6D6D616E642D73656E6465722E6765742D6E +616D65015C0140020473656C66DA0004746578741901000400235B6D6574686F645D636F6D6D61 +6E642D73656E6465722E73656E642D6D657373616765015D04002A5B6D6574686F645D636F6D6D +616E642D73656E6465722E73656E642D73797374656D2D6D657373616765015D0400215B6D6574 +686F645D636F6D6D616E642D73656E6465722E73656E642D6572726F72015D0140020473656C66 +DA0005636F756E747A01000400285B6D6574686F645D636F6D6D616E642D73656E6465722E7365 +742D737563636573732D636F756E74015E0140010473656C66DA00007F0400205B6D6574686F64 +5D636F6D6D616E642D73656E6465722E69732D706C61796572015F0400215B6D6574686F645D63 +6F6D6D616E642D73656E6465722E69732D636F6E736F6C65015F016B270140010473656C66DA00 +00E0000400205B6D6574686F645D636F6D6D616E642D73656E6465722E61732D706C6179657201 +610140010473656C66DA00002E0400275B6D6574686F645D636F6D6D616E642D73656E6465722E +7065726D697373696F6E2D6C6576656C01620140020473656C66DA00056C6576656C2E007F0400 +2B5B6D6574686F645D636F6D6D616E642D73656E6465722E6861732D7065726D697373696F6E2D +6C6576656C01630168130140030473656C66DA0006736572766572E400046E6F646573007F0400 +255B6D6574686F645D636F6D6D616E642D73656E6465722E6861732D7065726D697373696F6E01 +65016B090140010473656C66DA0000E60004001F5B6D6574686F645D636F6D6D616E642D73656E +6465722E706F736974696F6E0167016B290140010473656C66DA0000E80004001C5B6D6574686F +645D636F6D6D616E642D73656E6465722E776F726C6401690140010473656C66DA00000D040021 +5B6D6574686F645D636F6D6D616E642D73656E6465722E6765742D6C6F63616C65016A04002E5B +6D6574686F645D636F6D6D616E642D73656E6465722E73686F756C642D726563656976652D6665 +65646261636B015F0400365B6D6574686F645D636F6D6D616E642D73656E6465722E73686F756C +642D62726F6164636173742D636F6E736F6C652D746F2D6F7073015F04002A5B6D6574686F645D +636F6D6D616E642D73656E6465722E73686F756C642D747261636B2D6F7574707574015F016852 +0140020473656C66EB00036B65797300D10004001F5B6D6574686F645D636F6E73756D65642D61 +7267732E6765742D76616C7565016C017073016953014002056E616D6573ED000B646573637269 +7074696F6E7300EE000400145B636F6E7374727563746F725D636F6D6D616E64016F0168530140 +020473656C66F000046E6F6465D40001000400145B6D6574686F645D636F6D6D616E642E746865 +6E01710140020473656C66F0000A68616E646C65722D69647901000400275B6D6574686F645D63 +6F6D6D616E642E657865637574652D776974682D68616E646C65722D6964017203001C70756D70 +6B696E3A706C7567696E2F636F6D6D616E6440302E312E3005650203001712736572766572626F +756E642D7061636B65740203001812736572766572626F756E642D7061636B65740142F3040203 +02011C040009626C6F636B2D706F73030000020302013F04000967616D652D6D6F646503000202 +0302011504000468616E640300040203020125040008706F736974696F6E030006020302011704 +000A636C69636B2D74797065030008020302011404000A6974656D2D737461636B03000A020302 +010E04000B656E6368616E746D656E7403000C020302013104000B64616D6167652D7479706503 +000E020302011804000673637265656E0300100203020155040006706C61796572030012020302 +010804000E746578742D636F6D706F6E656E740300140203020140040005776F726C6403001602 +030201660400176A6176612D736572766572626F756E642D7061636B6574030018020302014804 +00176A6176612D636C69656E74626F756E642D7061636B657403001A020302016704001A626564 +726F636B2D736572766572626F756E642D7061636B657403001C020302014904001A626564726F +636B2D636C69656E74626F756E642D7061636B657403001E020302013404000475756964030020 +02030201470400066469616C6F67030022017103046A61766101190007626564726F636B011D00 +07756E6B6E6F776E0000040012736572766572626F756E642D7061636B6574030024017103046A +617661011B0007626564726F636B011F0007756E6B6E6F776E0000040012636C69656E74626F75 +6E642D7061636B6574030026016D0507686967686573740468696768066E6F726D616C036C6F77 +066C6F7765737404000E6576656E742D7072696F7269747903002801691301691501720306706C +617965722A0C6A6F696E2D6D6573736167652B0963616E63656C6C65647F040016706C61796572 +2D6A6F696E2D6576656E742D6461746103002C01720306706C617965722A0D6C656176652D6D65 +73736167652B0963616E63656C6C65647F040017706C617965722D6C656176652D6576656E742D +6461746103002E01720306706C617965722A0C6B69636B2D6D6573736167652B0963616E63656C +6C65647F040017706C617965722D6C6F67696E2D6576656E742D6461746103003001702A01707D +016B3301720506706C617965722A076D657373616765730A726563697069656E74733209736967 +6E6174757265340963616E63656C6C65647F040016706C617965722D636861742D6576656E742D +6461746103003501720306706C617965722A07636F6D6D616E64730963616E63656C6C65647F04 +001E706C617965722D636F6D6D616E642D73656E642D6576656E742D6461746103003701720306 +706C617965722A0A7065726D697373696F6E73117065726D697373696F6E2D726573756C747F04 +0022706C617965722D7065726D697373696F6E2D636865636B2D6576656E742D64617461030039 +01720406706C617965722A0D66726F6D2D706F736974696F6E070B746F2D706F736974696F6E07 +0963616E63656C6C65647F040016706C617965722D6D6F76652D6576656E742D6461746103003B +01720406706C617965722A0D66726F6D2D706F736974696F6E070B746F2D706F736974696F6E07 +0963616E63656C6C65647F04001A706C617965722D74656C65706F72742D6576656E742D646174 +6103003D01691701720706706C617965722A0E70726576696F75732D776F726C643F096E65772D +776F726C643F08706F736974696F6E070379617776057069746368760963616E63656C6C65647F +04001E706C617965722D6368616E67652D776F726C642D6576656E742D64617461030040017207 +06706C617965722A0E70726576696F75732D776F726C643F0F7265737061776E65642D776F726C +643F08706F736974696F6E0703796177760570697463687605616C6976657F040019706C617965 +722D7265737061776E2D6576656E742D6461746103004201720206706C617965722A06616D6F75 +6E747A04001C706C617965722D6578702D6368616E67652D6576656E742D646174610300440172 +0406706C617965722A0D70726576696F75732D736C6F747D086E65772D736C6F747D0963616E63 +656C6C65647F04001B706C617965722D6974656D2D68656C642D6576656E742D64617461030046 +01720206706C617965722A096D61696E2D68616E6405040023706C617965722D6368616E676564 +2D6D61696E2D68616E642D6576656E742D6461746103004801720406706C617965722A11707265 +76696F75732D67616D656D6F6465030C6E65772D67616D656D6F6465030963616E63656C6C6564 +7F040021706C617965722D67616D656D6F64652D6368616E67652D6576656E742D646174610300 +4A01720306706C617965722A076368616E6E656C73046461746133040020706C617965722D6375 +73746F6D2D7061796C6F61642D6576656E742D6461746103004C016D070766697368696E670B63 +61756768742D666973680D6361756768742D656E7469747909696E2D67726F756E640E6661696C +65642D617474656D7074077265656C2D696E0462697465040011706C617965722D666973682D73 +7461746503004E016B2101720806706C617965722A0B6361756768742D75756964D0000B636175 +6768742D747970657309686F6F6B2D7575696421057374617465CF000468616E64050B6578702D +746F2D64726F707A0963616E63656C6C65647F040016706C617965722D666973682D6576656E74 +2D6461746103005101720606706C617965722A086567672D7575696421086861746368696E677F +0B6E756D2D686174636865737D0D6861746368696E672D74797065730963616E63656C6C65647F +04001B706C617965722D6567672D7468726F772D6576656E742D64617461030053016D0308696E +7465726163740661747461636B0B696E7465726163742D6174040019656E746974792D696E7465 +72616374696F6E2D616374696F6E030055016D04106C6566742D636C69636B2D626C6F636B0E6C +6566742D636C69636B2D6169720F72696768742D636C69636B2D6169721172696768742D636C69 +636B2D626C6F636B04000F696E7465726163742D616374696F6E030057016B0101720506706C61 +7965722A06616374696F6ED8000B636C69636B65642D706F73D90005626C6F636B730963616E63 +656C6C65647F04001A706C617965722D696E7465726163742D6576656E742D6461746103005A01 +720306706C617965722A0B69732D736E65616B696E677F0963616E63656C6C65647F04001E706C +617965722D746F67676C652D736E65616B2D6576656E742D6461746103005C01720306706C6179 +65722A0969732D666C79696E677F0963616E63656C6C65647F04001F706C617965722D746F6767 +6C652D666C696768742D6576656E742D6461746103005E01720306706C617965722A0C69732D73 +7072696E74696E677F0963616E63656C6C65647F04001F706C617965722D746F67676C652D7370 +72696E742D6576656E742D6461746103006001720406706C617965722A09656E746974792D6964 +7A06616374696F6ED6000963616E63656C6C65647F040029706C617965722D696E746572616374 +2D756E6B6E6F776E2D656E746974792D6576656E742D64617461030062016B1101690B016BE500 +01720906706C617965722A0B77696E646F772D74797065E4000A636C69636B2D74797065090473 +6C6F747C087261772D736C6F747C0C636C69636B65642D6974656DE60006637572736F72E6000D +686F746261722D627574746F6E7A0963616E63656C6C65647F04001A696E76656E746F72792D63 +6C69636B2D6576656E742D6461746103006701720206706C617965722A0B77696E646F772D7479 +7065E40004001A696E76656E746F72792D636C6F73652D6576656E742D64617461030069017206 +0C7461726765742D776F726C643F0873746174652D69647B09626C6F636B2D706F73010B6F6C64 +2D63757272656E747A0B6E65772D63757272656E747A0963616E63656C6C65647F040019626C6F +636B2D72656473746F6E652D6576656E742D6461746103006B016B2A01720606706C61796572ED +0005626C6F636B7309626C6F636B2D706F730103657870790B73686F756C642D64726F707F0963 +616E63656C6C65647F040016626C6F636B2D627265616B2D6576656E742D6461746103006E0172 +030E69676E6974696E672D626C6F636B7305626C6F636B730963616E63656C6C65647F04001562 +6C6F636B2D6275726E2D6576656E742D646174610300700172050E626C6F636B2D746F2D627569 +6C6473096275696C6461626C657F06706C617965722A05626C6F636B730963616E63656C6C6564 +7F04001A626C6F636B2D63616E2D6275696C642D6576656E742D646174610300720172070C7461 +726765742D776F726C643F096F6C642D626C6F636B730C6F6C642D73746174652D69647B096E65 +772D626C6F636B730C6E65772D73746174652D69647B09626C6F636B2D706F73010963616E6365 +6C6C65647F040015626C6F636B2D67726F772D6576656E742D6461746103007401720606706C61 +7965722A0C626C6F636B2D706C616365647314626C6F636B2D706C616365642D616761696E7374 +7309626C6F636B2D706F73010963616E2D6275696C647F0963616E63656C6C65647F040016626C +6F636B2D706C6163652D6576656E742D64617461030076016B7301720306706C617965722A0766 +6F726D2D6964790D726573706F6E73652D64617461F800040020626564726F636B2D666F726D2D +726573706F6E73652D6576656E742D6461746103007901720406706C617965722A026964730770 +61796C6F6164340963616E63656C6C65647F04001E6469616C6F672D636C69636B2D616374696F +6E2D6576656E742D6461746103007B01720306706C617965722A066469616C6F67230963616E63 +656C6C65647F0400166469616C6F672D73686F772D6576656E742D6461746103007D0172020670 +6C617965722A0963616E63656C6C65647F0400176469616C6F672D636C6561722D6576656E742D +6461746103007F01720207636F6D6D616E64730963616E63656C6C65647F040019736572766572 +2D636F6D6D616E642D6576656E742D646174610300810101720204686F73747304706F72747B04 +00187365727665722D6C6973742D70696E672D616464726573730300830101720608686F73746E +616D657307616464726573738401046D6F74642B0B6D61782D706C6179657273790B6E756D2D70 +6C6179657273790766617669636F6EF80004001B7365727665722D6C6973742D70696E672D6576 +656E742D6461746103008501016D0207737461727475700672656C6F6164040010736572766572 +2D6C6F61642D7479706503008701017201096C6F61642D7479706588010400167365727665722D +6C6F61642D6576656E742D64617461030089010172070C7461726765742D776F726C643F117072 +6576696F75732D706F736974696F6E010C70726576696F75732D796177760E70726576696F7573 +2D7069746368760C6E65772D706F736974696F6E01076E65772D79617776096E65772D70697463 +6876040017737061776E2D6368616E67652D6576656E742D6461746103008B01017203076D6573 +736167652B0673656E6465722B0963616E63656C6C65647F04001B7365727665722D62726F6164 +636173742D6576656E742D6461746103008D01017201047469636B7A04001C7365727665722D74 +69636B2D73746172742D6576656E742D6461746103008F01017202047469636B7A0E6475726174 +696F6E2D6E616E6F737804001A7365727665722D7469636B2D656E642D6576656E742D64617461 +0300910101720506706C617965722A067061636B657425097061636B65742D69647A0B7261772D +7061796C6F6164330963616E63656C6C65647F04001A7061636B65742D72656365697665642D65 +76656E742D646174610300930101720506706C617965722A067061636B657427097061636B6574 +2D69647A0B7261772D7061796C6F6164330963616E63656C6C65647F0400167061636B65742D73 +656E742D6576656E742D646174610300950101720506706C617965722A09656E746974792D6964 +7A06616374696F6ED60008736E65616B696E677F0963616E63656C6C65647F040021706C617965 +722D696E7465726163742D656E746974792D6576656E742D64617461030097010172040C746172 +6765742D776F726C643F076368756E6B2D787A076368756E6B2D7A7A0963616E63656C6C65647F +0400156368756E6B2D6C6F61642D6576656E742D64617461030099010172040C7461726765742D +776F726C643F076368756E6B2D787A076368756E6B2D7A7A0963616E63656C6C65647F04001563 +68756E6B2D736176652D6576656E742D6461746103009B010172040C7461726765742D776F726C +643F076368756E6B2D787A076368756E6B2D7A7A0963616E63656C6C65647F0400156368756E6B +2D73656E642D6576656E742D6461746103009D0101720409656E746974792D69647A0664616D61 +6765760B64616D6167652D747970650F0963616E63656C6C65647F040018656E746974792D6461 +6D6167652D6576656E742D6461746103009F0101720209656E746974792D69647A0B64726F7070 +65642D6578707A040017656E746974792D64656174682D6576656E742D646174610300A1010172 +0506706C617965722A0D64656174682D6D6573736167652B0B64726F707065642D6578707A0E6B +6565702D696E76656E746F72797F0963616E63656C6C65647F040017706C617965722D64656174 +682D6576656E742D646174610300A30101720509656E746974792D69647A0B656E746974792D74 +7970657308706F736974696F6E070C7461726765742D776F726C643F0963616E63656C6C65647F +040017656E746974792D737061776E2D6576656E742D646174610300A50101720309656E746974 +792D69647A0D6475726174696F6E2D73656373760963616E63656C6C65647F040019656E746974 +792D636F6D627573742D6576656E742D646174610300A70101720309656E746974792D69647A06 +616D6F756E74760963616E63656C6C65647F04001F656E746974792D72656761696E2D6865616C +74682D6576656E742D646174610300A90101720309656E746974792D69647A06616D6F756E747A +0963616E63656C6C65647F04001C656E746974792D6169722D6368616E67652D6576656E742D64 +6174610300AB01017204096661746865722D69647A096D6F746865722D69647A086368696C642D +69647A0963616E63656C6C65647F040017656E746974792D62726565642D6576656E742D646174 +610300AD0101720309656E746974792D69647A0D6469736D6F756E7465642D69647A0963616E63 +656C6C65647F04001A656E746974792D6469736D6F756E742D6576656E742D646174610300AF01 +01720409656E746974792D69647A05636F6C6F727306706C61796572ED000963616E63656C6C65 +647F040015656E746974792D6479652D6576656E742D646174610300B101016B7A01720409656E +746974792D69647A0F68756D616E2D656E746974792D6964B3010D7469636B732D696E2D6C6F76 +657A0963616E63656C6C65647F040021656E746974792D656E7465722D6C6F76652D6D6F64652D +6576656E742D646174610300B40101720409656E746974792D69647A08706F736974696F6E070A +7969656C642D72617465760963616E63656C6C65647F040019656E746974792D6578706C6F6465 +2D6576656E742D646174610300B60101720309656E746974792D69647A0A6D6F756E7465642D69 +647A0963616E63656C6C65647F040017656E746974792D6D6F756E742D6576656E742D64617461 +0300B80101720409656E746974792D69647A096974656D2D6E616D657305636F756E747D096361 +6E63656C6C65647F04001D656E746974792D7069636B75702D6974656D2D6576656E742D646174 +610300BA0101720309656E746974792D69647A0A706F7274616C2D706F73010963616E63656C6C +65647F040018656E746974792D706F7274616C2D6576656E742D646174610300BC010172020965 +6E746974792D69647A0963616E63656C6C65647F04001B656E746974792D726573757272656374 +2D6576656E742D646174610300BE0101720409656E746974792D69647A0B776561706F6E2D6E61 +6D657305666F726365760963616E63656C6C65647F04001B656E746974792D73686F6F742D626F +772D6576656E742D646174610300C00101720309656E746974792D69647A056F776E65722A0963 +616E63656C6C65647F040016656E746974792D74616D652D6576656E742D646174610300C20101 +720309656E746974792D69647A097461726765742D6964B3010963616E63656C6C65647F040018 +656E746974792D7461726765742D6576656E742D646174610300C40101720409656E746974792D +69647A0D66726F6D2D706F736974696F6E070B746F2D706F736974696F6E070963616E63656C6C +65647F04001A656E746974792D74656C65706F72742D6576656E742D646174610300C601017203 +09656E746974792D69647A0A69732D676C6964696E677F0963616E63656C6C65647F04001E656E +746974792D746F67676C652D676C6964652D6576656E742D646174610300C80101720409656E74 +6974792D69647A0D6E65772D656E746974792D69647A107472616E73666F726D2D726561736F6E +730963616E63656C6C65647F04001B656E746974792D7472616E73666F726D2D6576656E742D64 +6174610300CA0101720609656E746974792D69647A0B656E746974792D747970657308706F7369 +74696F6E070C7461726765742D776F726C643F0C737061776E2D726561736F6E730963616E6365 +6C6C65647F04001963726561747572652D737061776E2D6576656E742D646174610300CC010172 +0409656E746974792D69647A0D63757272656E742D706861736573096E65772D70686173657309 +63616E63656C6C65647F040024656E6465722D647261676F6E2D6368616E67652D70686173652D +6576656E742D646174610300CE0101720309656E746974792D69647A09626C6F636B2D706F7301 +0963616E63656C6C65647F04001C656E746974792D627265616B2D646F6F722D6576656E742D64 +6174610300D00101720409656E746974792D69647A09626C6F636B2D706F7301096E65772D626C +6F636B730963616E63656C6C65647F04001E656E746974792D6368616E67652D626C6F636B2D65 +76656E742D646174610300D20101720509656E746974792D69647A0B64616D616765722D706F73 +D9000664616D61676576056361757365730963616E63656C6C65647F040021656E746974792D64 +616D6167652D62792D626C6F636B2D6576656E742D646174610300D40101720509656E74697479 +2D69647A0A64616D616765722D69647A0664616D61676576056361757365730963616E63656C6C +65647F040022656E746974792D64616D6167652D62792D656E746974792D6576656E742D646174 +610300D60101720409656E746974792D69647A096974656D2D6E616D657305636F756E747D0963 +616E63656C6C65647F04001B656E746974792D64726F702D6974656D2D6576656E742D64617461 +0300D80101720309656E746974792D69647A09626C6F636B2D706F73010963616E63656C6C6564 +7F04001D656E746974792D656E7465722D626C6F636B2D6576656E742D646174610300DA010172 +0309656E746974792D69647A0A65786861757374696F6E760963616E63656C6C65647F04001C65 +6E746974792D65786861757374696F6E2D6576656E742D646174610300DC0101720309656E7469 +74792D69647A09626C6F636B2D706F73010963616E63656C6C65647F04001A656E746974792D69 +6E7465726163742D6576656E742D646174610300DE0101720409656E746974792D69647A096869 +742D62792D6964B301096B6E6F636B6261636B070963616E63656C6C65647F04001B656E746974 +792D6B6E6F636B6261636B2D6576656E742D646174610300E00101720409656E746974792D6964 +7A09626C6F636B2D706F73010A626C6F636B2D6E616D65730963616E63656C6C65647F04001765 +6E746974792D706C6163652D6576656E742D646174610300E20101720309656E746974792D6964 +7A04706F7365730963616E63656C6C65647F04001D656E746974792D706F73652D6368616E6765 +2D6576656E742D646174610300E40101720509656E746974792D69647A0B6566666563742D6E61 +6D6573086475726174696F6E7A09616D706C69666965727D0963616E63656C6C65647F04001F65 +6E746974792D706F74696F6E2D6566666563742D6576656E742D646174610300E6010172030965 +6E746974792D69647A057370656C6C730963616E63656C6C65647F04001C656E746974792D7370 +656C6C2D636173742D6576656E742D646174610300E80101720409656E746974792D69647A0974 +61726765742D6964B30106726561736F6E730963616E63656C6C65647F040026656E746974792D +7461726765742D6C6976696E672D656E746974792D6576656E742D646174610300EA0101720309 +656E746974792D69647A0B69732D7377696D6D696E677F0963616E63656C6C65647F04001D656E +746974792D746F67676C652D7377696D2D6576656E742D646174610300EC0101720409656E7469 +74792D69647A067261646975737604666972657F0963616E63656C6C65647F04001A6578706C6F +73696F6E2D7072696D652D6576656E742D646174610300EE0101720209656E746974792D69647A +0963616E63656C6C65647F04001B66697265776F726B2D6578706C6F64652D6576656E742D6461 +74610300F00101720309656E746974792D69647A0A666F6F642D6C6576656C7D0963616E63656C +6C65647F04001C666F6F642D6C6576656C2D6368616E67652D6576656E742D646174610300F201 +01720209656E746974792D69647A0963616E63656C6C65647F0400176974656D2D646573706177 +6E2D6576656E742D646174610300F40101720309656E746974792D69647A097461726765742D69 +647A0963616E63656C6C65647F0400156974656D2D6D657267652D6576656E742D646174610300 +F60101720409656E746974792D69647A08706F736974696F6E07096974656D2D6E616D65730963 +616E63656C6C65647F0400156974656D2D737061776E2D6576656E742D646174610300F8010170 +E50001720409656E746974792D69647A0A696E7075742D6974656DE500076F7574636F6D65FA01 +0963616E63656C6C65647F0400187069676C696E2D6261727465722D6576656E742D6461746103 +00FB0101720409656E746974792D69647A0C6869742D706F736974696F6E070D6869742D656E74 +6974792D6964B3010963616E63656C6C65647F04001970726F6A656374696C652D6869742D6576 +656E742D646174610300FD0101720309656E746974792D69647A0A73686F6F7465722D6964B301 +0963616E63656C6C65647F04001C70726F6A656374696C652D6C61756E63682D6576656E742D64 +6174610300FF0101720409656E746974792D69647A096479652D636F6C6F727D09706C61796572 +2D6964B3010963616E63656C6C65647F04001973686565702D6479652D776F6F6C2D6576656E74 +2D646174610300810201720209656E746974792D69647A0963616E63656C6C65647F04001C7368 +6565702D726567726F772D776F6F6C2D6576656E742D646174610300830201720309656E746974 +792D69647A05636F756E747A0963616E63656C6C65647F040016736C696D652D73706C69742D65 +76656E742D646174610300850201720309656E746974792D69647A0C69732D736869766572696E +677F0963616E63656C6C65647F040025737472696465722D74656D70657261747572652D636861 +6E67652D6576656E742D646174610300870201720309656E746974792D69647A0C726563697065 +2D696E6465787A0963616E63656C6C65647F04002176696C6C616765722D616371756972652D74 +726164652D6576656E742D646174610300890201720409656E746974792D69647A0A70726F6665 +7373696F6E7306726561736F6E730963616E63656C6C65647F04002176696C6C616765722D6361 +726565722D6368616E67652D6576656E742D6461746103008B0201720309656E746974792D6964 +7A10726573746F636B2D7175616E746974797A0963616E63656C6C65647F04002376696C6C6167 +65722D7265706C656E6973682D74726164652D6576656E742D6461746103008D0201720509656E +746974792D69647A097461726765742D69647A096F6C642D616E6765727A096E65772D616E6765 +727A0963616E63656C6C65647F04001E77617264656E2D616E6765722D6368616E67652D657665 +6E742D6461746103008F0201707A01720309656E746974792D69647A1161666665637465642D65 +6E74697469657391020963616E63656C6C65647F040022617265612D6566666563742D636C6F75 +642D6170706C792D6576656E742D646174610300920201720409656E746974792D69647A0A6F6C +642D616D6F756E74790A6E65772D616D6F756E74790963616E63656C6C65647F0400226172726F +772D626F64792D636F756E742D6368616E67652D6576656E742D64617461030094020172030965 +6E746974792D69647A0869732D6177616B657F0963616E63656C6C65647F04001B6261742D746F +67676C652D736C6565702D6576656E742D646174610300960201720409656E746974792D69647A +0C6C696768746E696E672D6964B301056361757365730963616E63656C6C65647F040018637265 +657065722D706F7765722D6576656E742D646174610300980201720409656E746974792D69647A +09636F6D62757374657201086475726174696F6E760963616E63656C6C65647F040022656E7469 +74792D636F6D627573742D62792D626C6F636B2D6576656E742D6461746103009A020172040965 +6E746974792D69647A0C636F6D6275737465722D69647A086475726174696F6E760963616E6365 +6C6C65647F040023656E746974792D636F6D627573742D62792D656E746974792D6576656E742D +6461746103009C0201720609656E746974792D69647A096869742D62792D69647A05666F726365 +75017875017A750963616E63656C6C65647F040025656E746974792D6B6E6F636B6261636B2D62 +792D656E746974792D6576656E742D6461746103009E0201720309656E746974792D69647A086C +6F636174696F6E010963616E63656C6C65647F04001E656E746974792D706F7274616C2D656E74 +65722D6576656E742D646174610300A00201720409656E746974792D69647A0866726F6D2D706F +730106746F2D706F73D9000963616E63656C6C65647F04001D656E746974792D706F7274616C2D +657869742D6576656E742D646174610300A20201720309656E746974792D69647A056361757365 +730963616E63656C6C65647F040018656E746974792D72656D6F76652D6576656E742D64617461 +0300A40201720309656E746974792D69647A09626C6F636B2D706F73010963616E63656C6C6564 +7F04001E656E746974792D7461726765742D626C6F636B2D6576656E742D646174610300A60201 +720309656E746974792D69647A06726561736F6E730963616E63656C6C65647F040019656E7469 +74792D756E6C656173682D6576656E742D646174610300A80201720509656E746974792D69647A +0A657870657269656E63657A086C6F636174696F6E010B73686F772D6566666563747F0963616E +63656C6C65647F0400156578702D626F74746C652D6576656E742D646174610300AA0201720309 +656E746974792D69647A05706F776572760963616E63656C6C65647F040015686F7273652D6A75 +6D702D6576656E742D646174610300AC0201720409656E746974792D69647A086C6F636174696F +6E010B706F74696F6E2D6974656D730963616E63656C6C65647F0400226C696E676572696E672D +706F74696F6E2D73706C6173682D6576656E742D646174610300AE0201720409656E746974792D +69647A0C6C696768746E696E672D69647A0D7069672D7A6F6D6269652D69647A0963616E63656C +6C65647F0400127069672D7A61702D6576656E742D646174610300B00201720409656E74697479 +2D69647A097461726765742D6964B301096E65772D616E6765727A0963616E63656C6C65647F04 +001B7069672D7A6F6D6269652D616E6765722D6576656E742D646174610300B20201720509656E +746974792D69647A086C6F636174696F6E010B706F74696F6E2D6974656D731161666665637465 +642D656E74697469657391020963616E63656C6C65647F040018706F74696F6E2D73706C617368 +2D6576656E742D646174610300B40201720309656E746974792D69647A0B737061776E65722D70 +6F73010963616E63656C6C65647F040018737061776E65722D737061776E2D6576656E742D6461 +74610300B60201720309656E746974792D69647A0B737061776E65722D706F73010963616E6365 +6C6C65647F04001E747269616C2D737061776E65722D737061776E2D6576656E742D6461746103 +00B80201720409656E746974792D69647A097461726765742D69647A1172657075746174696F6E +2D6368616E67657A0963616E63656C6C65647F04002576696C6C616765722D7265707574617469 +6F6E2D6368616E67652D6576656E742D646174610300BA0201720306706C617965722A09697465 +6D2D6E616D65730963616E63656C6C65647F04001E706C617965722D6974656D2D636F6E73756D +652D6576656E742D646174610300BC0201720406706C617965722A096974656D2D6E616D657306 +64616D6167657A0963616E63656C6C65647F04001D706C617965722D6974656D2D64616D616765 +2D6576656E742D646174610300BE0201720406706C617965722A096974656D2D6E616D65730563 +6F756E747D0963616E63656C6C65647F04001B706C617965722D64726F702D6974656D2D657665 +6E742D646174610300C00201720306706C617965722A076265642D706F73010963616E63656C6C +65647F04001B706C617965722D6265642D656E7465722D6576656E742D646174610300C2020172 +0206706C617965722A076265642D706F730104001B706C617965722D6265642D6C656176652D65 +76656E742D646174610300C40201720406706C617965722A09626C6F636B2D706F730106627563 +6B6574730963616E63656C6C65647F04001E706C617965722D6275636B65742D656D7074792D65 +76656E742D646174610300C60201720406706C617965722A09626C6F636B2D706F730106627563 +6B6574730963616E63656C6C65647F04001D706C617965722D6275636B65742D66696C6C2D6576 +656E742D646174610300C80201720406706C617965722A076D6573736167657306666F726D6174 +2B0963616E63656C6C65647F04001C6173796E632D706C617965722D636861742D6576656E742D +646174610300CA020172050B706C617965722D6E616D65730B706C617965722D75756964730A69 +702D61646472657373730C6B69636B2D6D6573736167652B0963616E63656C6C65647F04002161 +73796E632D706C617965722D7072652D6C6F67696E2D6576656E742D646174610300CC02017203 +06706C617965722A0E616476616E63656D656E742D6964730963616E63656C6C65647F04002270 +6C617965722D616476616E63656D656E742D646F6E652D6576656E742D646174610300CE020172 +0306706C617965722A0E616E696D6174696F6E2D74797065730963616E63656C6C65647F04001B +706C617965722D616E696D6174696F6E2D6576656E742D646174610300D00201720406706C6179 +65722A0E61726D6F722D7374616E642D69647A04736C6F747D0963616E63656C6C65647F040028 +706C617965722D61726D6F722D7374616E642D6D616E6970756C6174652D6576656E742D646174 +610300D20201720406706C617965722A09656E746974792D69647A0B6275636B65742D6974656D +730963616E63656C6C65647F04001F706C617965722D6275636B65742D656E746974792D657665 +6E742D646174610300D40201720406706C617965722A0A66726F6D2D776F726C643F08746F2D77 +6F726C643F0963616E63656C6C65647F04001F706C617965722D6368616E6765642D776F726C64 +2D6576656E742D646174610300D60201720306706C617965722A076368616E6E656C730963616E +63656C6C65647F040019706C617965722D6368616E6E656C2D6576656E742D646174610300D802 +01720306706C617965722A07636F6D6D616E64730963616E63656C6C65647F040024706C617965 +722D636F6D6D616E642D70726570726F636573732D6576656E742D646174610300DA0201707301 +720606706C617965722A04736C6F7479057061676573DC02057469746C65F800077369676E696E +677F0963616E63656C6C65647F04001B706C617965722D656469742D626F6F6B2D6576656E742D +646174610300DD0201720306706C617965722A0B66697265776F726B2D69647A0963616E63656C +6C65647F04001E706C617965722D656C797472612D626F6F73742D6576656E742D646174610300 +DF0201720306706C617965722A0C6E65772D636F6F6C646F776E7A0963616E63656C6C65647F04 +0025706C617965722D6578702D636F6F6C646F776E2D6368616E67652D6576656E742D64617461 +0300E10201720406706C617965722A09626C6F636B2D706F73010F6861727665737465642D6974 +656D73FA010963616E63656C6C65647F04001F706C617965722D686172766573742D626C6F636B +2D6576656E742D646174610300E30201720306706C617965722A09656E746974792D69647A0963 +616E63656C6C65647F04001D706C617965722D686964652D656E746974792D6576656E742D6461 +74610300E50201720206706C617965722A096974656D2D6E616D657304001C706C617965722D69 +74656D2D627265616B2D6576656E742D646174610300E70201720506706C617965722A09697465 +6D2D6E616D65730D7265706169722D616D6F756E747A0C6578702D636F6E73756D65647A096361 +6E63656C6C65647F04001B706C617965722D6974656D2D6D656E642D6576656E742D6461746103 +00E90201720306706C617965722A06726561736F6E730963616E63656C6C65647F040016706C61 +7965722D6B69636B2D6576656E742D646174610300EB0201720406706C617965722A09656E7469 +74792D69647A09686F6C6465722D69647A0963616E63656C6C65647F04001E706C617965722D6C +656173682D656E746974792D6576656E742D646174610300ED0201720306706C617965722A096F +6C642D6C6576656C7A096E65772D6C6576656C7A04001E706C617965722D6C6576656C2D636861 +6E67652D6576656E742D646174610300EF0201720306706C617965722A0A6E65772D6C6F63616C +65730963616E63656C6C65647F04001F706C617965722D6C6F63616C652D6368616E67652D6576 +656E742D646174610300F10201720406706C617965722A09656E746974792D69647A046E616D65 +2B0963616E63656C6C65647F04001D706C617965722D6E616D652D656E746974792D6576656E74 +2D646174610300F30201720406706C617965722A09626C6F636B2D706F73010869732D66726F6E +747F0963616E63656C6C65647F04001B706C617965722D6F70656E2D7369676E2D6576656E742D +646174610300F50201720406706C617965722A0866726F6D2D706F730106746F2D706F73D90009 +63616E63656C6C65647F040018706C617965722D706F7274616C2D6576656E742D646174610300 +F7020172050B706C617965722D6E616D65730B706C617965722D75756964730A69702D61646472 +657373730C6B69636B2D6D6573736167652B0963616E63656C6C65647F04001B706C617965722D +7072652D6C6F67696E2D6576656E742D646174610300F90201720306706C617965722A09697465 +6D2D6E616D65730963616E63656C6C65647F040019706C617965722D726970746964652D657665 +6E742D646174610300FB0201720406706C617965722A09656E746974792D69647A0468616E647D +0963616E63656C6C65647F04001E706C617965722D73686561722D656E746974792D6576656E74 +2D646174610300FD0201720306706C617965722A09656E746974792D69647A0963616E63656C6C +65647F04001D706C617965722D73686F772D656E746974792D6576656E742D646174610300FF02 +01720406706C617965722A096E65772D737061776ED90006666F726365647F0963616E63656C6C +65647F04001E706C617965722D737061776E2D6368616E67652D6576656E742D64617461030081 +0301720406706C617965722A0C7374617469737469632D69647306616D6F756E747A0963616E63 +656C6C65647F040025706C617965722D7374617469737469632D696E6372656D656E742D657665 +6E742D646174610300830301720206706C617965722A0963616E63656C6C65647F04001C706C61 +7965722D737761702D68616E64732D6576656E742D646174610300850301720406706C61796572 +2A09626C6F636B2D706F730104626F6F6BE5000963616E63656C6C65647F040023706C61796572 +2D74616B652D6C65637465726E2D626F6F6B2D6576656E742D646174610300870301720306706C +617965722A09656E746974792D69647A0963616E63656C6C65647F040020706C617965722D756E +6C656173682D656E746974792D6576656E742D646174610300890301720306706C617965722A08 +76656C6F63697479070963616E63656C6C65647F04001A706C617965722D76656C6F636974792D +6576656E742D6461746103008B0301720306706C617965722A05696E707574730963616E63656C +6C65647F040017706C617965722D696E7075742D6576656E742D6461746103008D030172070670 +6C617965722A09656E746974792D69647A09636C69636B65642D787509636C69636B65642D7975 +09636C69636B65642D7A750468616E647D0963616E63656C6C65647F040024706C617965722D69 +6E7465726163742D61742D656E746974792D6576656E742D6461746103008F0301720306706C61 +7965722A056C696E6B73DC020963616E63656C6C65647F04001C706C617965722D6C696E6B732D +73656E642D6576656E742D646174610300910301720306706C617965722A086172726F772D6964 +7A0963616E63656C6C65647F04001E706C617965722D7069636B75702D6172726F772D6576656E +742D646174610300930301720406706C617965722A097265636970652D696473086D616B652D61 +6C6C7F0963616E63656C6C65647F040023706C617965722D7265636970652D626F6F6B2D636C69 +636B2D6576656E742D646174610300950301720506706C617965722A09626F6F6B2D7479706573 +0769732D6F70656E7F0C69732D66696C746572696E677F0963616E63656C6C65647F04002D706C +617965722D7265636970652D626F6F6B2D73657474696E67732D6368616E67652D6576656E742D +646174610300970301720306706C617965722A097265636970652D6964730963616E63656C6C65 +647F040021706C617965722D7265636970652D646973636F7665722D6576656E742D6461746103 +00990301720306706C617965722A076368616E6E656C730963616E63656C6C65647F040022706C +617965722D72656769737465722D6368616E6E656C2D6576656E742D6461746103009B03017204 +06706C617965722A077061636B2D69647306737461747573730963616E63656C6C65647F040026 +706C617965722D7265736F757263652D7061636B2D7374617475732D6576656E742D6461746103 +009D0301720306706C617965722A09737061776E2D706F73070963616E63656C6C65647F040020 +706C617965722D737061776E2D6C6F636174696F6E2D6576656E742D6461746103009F03017203 +06706C617965722A076368616E6E656C730963616E63656C6C65647F040024706C617965722D75 +6E72656769737465722D6368616E6E656C2D6576656E742D646174610300A10301720207766963 +746F72797F0963616E63656C6C65647F040016726169642D66696E6973682D6576656E742D6461 +74610300A30301720304776176657903706F73010963616E63656C6C65647F04001A726169642D +737061776E2D776176652D6576656E742D646174610300A50301720206726561736F6E73096361 +6E63656C6C65647F040014726169642D73746F702D6576656E742D646174610300A70301720203 +706F73010963616E63656C6C65647F040017726169642D747269676765722D6576656E742D6461 +74610300A90301720406706C617965722A09626C6F636B2D706F73010B696E7374612D62726561 +6B7F0963616E63656C6C65647F040017626C6F636B2D64616D6167652D6576656E742D64617461 +0300AB0301720209626C6F636B2D706F73010963616E63656C6C65647F040017626C6F636B2D69 +676E6974652D6576656E742D646174610300AD030172030866726F6D2D706F730106746F2D706F +73010963616E63656C6C65647F040018626C6F636B2D66726F6D2D746F2D6576656E742D646174 +610300AF0301720209626C6F636B2D706F73010963616E63656C6C65647F040015626C6F636B2D +666F726D2D6576656E742D646174610300B10301720209626C6F636B2D706F73010963616E6365 +6C6C65647F040015626C6F636B2D666164652D6576656E742D646174610300B30301720309626C +6F636B2D706F7301096974656D2D6E616D65730963616E63656C6C65647F040019626C6F636B2D +64697370656E73652D6576656E742D646174610300B50301720309626C6F636B2D706F73010A79 +69656C642D72617465760963616E63656C6C65647F040018626C6F636B2D6578706C6F64652D65 +76656E742D646174610300B70301720309626C6F636B2D706F73010B6368616E6765642D706F73 +010963616E63656C6C65647F040018626C6F636B2D706879736963732D6576656E742D64617461 +0300B90301720309626C6F636B2D706F730109646972656374696F6E730963616E63656C6C6564 +7F04001E626C6F636B2D706973746F6E2D657874656E642D6576656E742D646174610300BB0301 +720309626C6F636B2D706F730109646972656374696F6E730963616E63656C6C65647F04001F62 +6C6F636B2D706973746F6E2D726574726163742D6576656E742D646174610300BD030172040962 +6C6F636B2D706F73010A696E737472756D656E7473046E6F74657D0963616E63656C6C65647F04 +00146E6F74652D706C61792D6576656E742D646174610300BF0301720406706C617965722A0962 +6C6F636B2D706F7301056C696E6573DC020963616E63656C6C65647F0400167369676E2D636861 +6E67652D6576656E742D646174610300C10301720209626C6F636B2D706F73010963616E63656C +6C65647F04001873706F6E67652D6162736F72622D6576656E742D646174610300C30301720309 +626C6F636B2D706F73010C7072696D652D726561736F6E730963616E63656C6C65647F04001474 +6E742D7072696D652D6576656E742D646174610300C503017201066D61702D69647A0400196D61 +702D696E697469616C697A652D6576656E742D646174610300C70301720309656E746974792D69 +647A1172656D6F7665722D656E746974792D6964B3010963616E63656C6C65647F04001868616E +67696E672D627265616B2D6576656E742D646174610300C90301720309656E746974792D69647A +1172656D6F7665722D656E746974792D69647A0963616E63656C6C65647F04002268616E67696E +672D627265616B2D62792D656E746974792D6576656E742D646174610300CB0301720509656E74 +6974792D69647A06706C61796572ED0009626C6F636B2D706F73010A626C6F636B2D6661636573 +0963616E63656C6C65647F04001868616E67696E672D706C6163652D6576656E742D6461746103 +00CD0301720309626C6F636B2D706F73010C7461726765742D776F726C643F0963616E63656C6C +65647F04001862656C6C2D7265736F6E6174652D6576656E742D646174610300CF030172050962 +6C6F636B2D706F73010C7461726765742D776F726C643F09656E746974792D6964B30109646972 +656374696F6EF8000963616E63656C6C65647F04001462656C6C2D72696E672D6576656E742D64 +6174610300D10301720509626C6F636B2D706F73010C7461726765742D776F726C643F06706C61 +7965722A046974656DE5000963616E63656C6C65647F040016626C6F636B2D62727573682D6576 +656E742D646174610300D30301720509626C6F636B2D706F73010C7461726765742D776F726C64 +3F06736F75726365E50006726573756C74E5000963616E63656C6C65647F040015626C6F636B2D +636F6F6B2D6576656E742D646174610300D50301720406706C617965722A09626C6F636B2D706F +73010C7461726765742D776F726C643F0C6974656D2D696E2D68616E64E50004001D626C6F636B +2D64616D6167652D61626F72742D6576656E742D646174610300D70301720509626C6F636B2D70 +6F73010C7461726765742D776F726C643F107461726765742D656E746974792D69647A04697465 +6DE5000963616E63656C6C65647F04001F626C6F636B2D64697370656E73652D61726D6F722D65 +76656E742D646174610300D90301720409626C6F636B2D706F73010C7461726765742D776F726C +643F056974656D73FA010963616E63656C6C65647F04001E626C6F636B2D64697370656E73652D +6C6F6F742D6576656E742D646174610300DB0301720509626C6F636B2D706F73010C7461726765 +742D776F726C643F06706C61796572ED00056974656D73FA010963616E63656C6C65647F04001A +626C6F636B2D64726F702D6974656D2D6576656E742D646174610300DD0301720309626C6F636B +2D706F73010C7461726765742D776F726C643F036578707A040014626C6F636B2D6578702D6576 +656E742D646174610300DF03016F02017B0170E10301720509626C6F636B2D706F73010C746172 +6765742D776F726C643F06706C61796572ED000E6368616E6765642D626C6F636B73E203096361 +6E63656C6C65647F04001A626C6F636B2D66657274696C697A652D6576656E742D646174610300 +E30301720406706C617965722A0C7461726765742D776F726C643F0D706C616365642D626C6F63 +6B73E2030963616E63656C6C65647F04001C626C6F636B2D6D756C74692D706C6163652D657665 +6E742D646174610300E50301720509626C6F636B2D706F73010C7461726765742D776F726C643F +0A67616D652D6576656E747310736F757263652D656E746974792D6964B3010963616E63656C6C +65647F04001D626C6F636B2D726563656976652D67616D652D6576656E742D646174610300E703 +01720509626C6F636B2D706F73010C7461726765742D776F726C643F107461726765742D656E74 +6974792D69647A046974656DE5000963616E63656C6C65647F04001D626C6F636B2D7368656172 +2D656E746974792D6576656E742D646174610300E9030172050A736F757263652D706F73010A74 +61726765742D706F73010C7461726765742D776F726C643F0C6E65772D73746174652D69647B09 +63616E63656C6C65647F040017626C6F636B2D7370726561642D6576656E742D646174610300EB +0301720409626C6F636B2D706F73010C7461726765742D776F726C643F0C62726577696E672D74 +696D657A0963616E63656C6C65647F04001862726577696E672D73746172742D6576656E742D64 +6174610300ED0301720609626C6F636B2D706F73010C7461726765742D776F726C643F04697465 +6DE50004736C6F747D0C636F6F6B696E672D74696D657A0963616E63656C6C65647F0400196361 +6D70666972652D73746172742D6576656E742D646174610300EF0301720709626C6F636B2D706F +73010C7461726765742D776F726C643F096F6C642D6C6576656C7A096E65772D6C6576656C7A06 +726561736F6E7309656E746974792D6964B3010963616E63656C6C65647F0400206361756C6472 +6F6E2D6C6576656C2D6368616E67652D6576656E742D646174610300F10301720409626C6F636B +2D706F73010C7461726765742D776F726C643F06726573756C74E5000963616E63656C6C65647F +040018637261667465722D63726166742D6576656E742D646174610300F30301720509656E7469 +74792D69647A09626C6F636B2D706F73010C7461726765742D776F726C643F0C6E65772D737461 +74652D69647B0963616E63656C6C65647F04001C656E746974792D626C6F636B2D666F726D2D65 +76656E742D646174610300F50301720409626C6F636B2D706F73010C7461726765742D776F726C +643F0C6E65772D73746174652D69647B0963616E63656C6C65647F04001D666C7569642D6C6576 +656C2D6368616E67652D6576656E742D646174610300F70301720209626C6F636B2D706F73010C +7461726765742D776F726C643F040020696E76656E746F72792D626C6F636B2D73746172742D65 +76656E742D646174610300F90301720309626C6F636B2D706F73010C7461726765742D776F726C +643F0963616E63656C6C65647F0400176C65617665732D64656361792D6576656E742D64617461 +0300FB0301720409626C6F636B2D706F73010C7461726765742D776F726C643F0C6E65772D6D6F +6973747572657A0963616E63656C6C65647F04001A6D6F6973747572652D6368616E67652D6576 +656E742D646174610300FD0301720409626C6F636B2D706F73010C7461726765742D776F726C64 +3F066368617267657A0963616E63656C6C65647F0400167363756C6B2D626C6F6F6D2D6576656E +742D646174610300FF0301720409626C6F636B2D706F73010C7461726765742D776F726C643F04 +6974656DE5000963616E63656C6C65647F04001D7661756C742D646973706C61792D6974656D2D +6576656E742D64617461030081040172030C7461726765742D776F726C643F10746F2D77656174 +6865722D73746174657F0963616E63656C6C65647F040019776561746865722D6368616E67652D +6576656E742D64617461030083040172030C7461726765742D776F726C643F10746F2D7468756E +6465722D73746174657F0963616E63656C6C65647F0400197468756E6465722D6368616E67652D +6576656E742D64617461030085040172010C7461726765742D776F726C643F040015776F726C64 +2D6C6F61642D6576656E742D64617461030087040172020C7461726765742D776F726C643F0963 +616E63656C6C65647F040017776F726C642D756E6C6F61642D6576656E742D6461746103008904 +0172040A776F726C642D6E616D65730E7374727563747572652D6E616D657303706F7301096361 +6E63656C6C65647F0400236173796E632D7374727563747572652D67656E65726174652D657665 +6E742D6461746103008B040172040A776F726C642D6E616D65730E7374727563747572652D6E61 +6D657303706F73010963616E63656C6C65647F0400206173796E632D7374727563747572652D73 +7061776E2D6576656E742D6461746103008D04017203076368756E6B2D787A076368756E6B2D7A +7A0963616E63656C6C65647F0400196368756E6B2D706F70756C6174652D6576656E742D646174 +6103008F04017203076368756E6B2D787A076368756E6B2D7A7A0963616E63656C6C65647F0400 +176368756E6B2D756E6C6F61642D6576656E742D6461746103009104017204076368756E6B2D78 +7A076368756E6B2D7A7A0C656E746974792D636F756E74790963616E63656C6C65647F04001865 +6E7469746965732D6C6F61642D6576656E742D6461746103009304017204076368756E6B2D787A +076368756E6B2D7A7A0C656E746974792D636F756E74790963616E63656C6C65647F04001A656E +7469746965732D756E6C6F61642D6576656E742D6461746103009504017203086576656E742D69 +647303706F73070963616E63656C6C65647F04001767656E657269632D67616D652D6576656E74 +2D64617461030097040172020A6C6F6F742D7461626C65730963616E63656C6C65647F0400186C +6F6F742D67656E65726174652D6576656E742D646174610300990401720303706F73010B706F72 +74616C2D74797065730963616E63656C6C65647F040018706F7274616C2D6372656174652D6576 +656E742D6461746103009B0401720403706F730107737065636965737309626F6E652D6D65616C +7F0963616E63656C6C65647F0400197374727563747572652D67726F772D6576656E742D646174 +6103009D040172020B736B69702D616D6F756E74780963616E63656C6C65647F04001474696D65 +2D736B69702D6576656E742D6461746103009F040172010C7461726765742D776F726C643F0400 +15776F726C642D696E69742D6576656E742D646174610300A1040172020A776F726C642D6E616D +65730963616E63656C6C65647F040015776F726C642D736176652D6576656E742D646174610300 +A30401720206706C617965722A0963616E63656C6C65647F040019696E76656E746F72792D6F70 +656E2D6576656E742D646174610300A50401720206706C617965722A0963616E63656C6C65647F +040019696E76656E746F72792D647261672D6576656E742D646174610300A70401720306706C61 +7965722A097265636970652D6964730963616E63656C6C65647F04001563726166742D6974656D +2D6576656E742D646174610300A90401720409626C6F636B2D706F73010B736F757263652D6974 +656D730B726573756C742D6974656D730963616E63656C6C65647F0400186675726E6163652D73 +6D656C742D6576656E742D646174610300AB0401720309626C6F636B2D706F73010A6675656C2D +6C6576656C7D0963616E63656C6C65647F04000F627265772D6576656E742D646174610300AD04 +01720309626C6F636B2D706F73010A6675656C2D706F7765727B0963616E63656C6C65647F0400 +1D62726577696E672D7374616E642D6675656C2D6576656E742D646174610300AF040172040962 +6C6F636B2D706F7301096675656C2D6974656D73096275726E2D74696D65790963616E63656C6C +65647F0400176675726E6163652D6275726E2D6576656E742D646174610300B10401720506706C +617965722A09626C6F636B2D706F7301076974656D2D6964730B6974656D2D616D6F756E74790A +6578702D6761696E65647604001A6675726E6163652D657874726163742D6576656E742D646174 +610300B30401720409626C6F636B2D706F73010B736F757263652D6974656D730C636F6F6B696E +672D74696D65790963616E63656C6C65647F04001E6675726E6163652D73746172742D736D656C +742D6576656E742D646174610300B50401720309626C6F636B2D706F73010A7365617263682D70 +6F73010963616E63656C6C65647F040022686F707065722D696E76656E746F72792D7365617263 +682D6576656E742D646174610300B70401720506706C617965722A04736C6F747C076974656D2D +6964730A6974656D2D636F756E747D0963616E63656C6C65647F04001D696E76656E746F72792D +63726561746976652D6576656E742D646174610300B90401720206706C617965722A0963616E63 +656C6C65647F04001D696E76656E746F72792D696E7465726163742D6576656E742D6461746103 +00BB040172050A736F757263652D706F73010A7461726765742D706F7301076974656D2D696473 +0B6974656D2D616D6F756E74790963616E63656C6C65647F04001E696E76656E746F72792D6D6F +76652D6974656D2D6576656E742D646174610300BD0401720409626C6F636B2D706F73010E6974 +656D2D656E746974792D69647A076974656D2D6964730963616E63656C6C65647F040020696E76 +656E746F72792D7069636B75702D6974656D2D6576656E742D646174610300BF0401720306706C +617965722A0B72656E616D652D74657874730B7265706169722D636F7374790400187072657061 +72652D616E76696C2D6576656E742D646174610300C10401720206706C617965722A0B72657375 +6C742D6974656DF80004001D707265706172652D6772696E6473746F6E652D6576656E742D6461 +74610300C30401720206706C617965722A0B726573756C742D6974656DF8000400237072657061 +72652D696E76656E746F72792D726573756C742D6576656E742D646174610300C5040172030670 +6C617965722A097265636970652D6964730963616E63656C6C65647F04001D707265706172652D +6974656D2D63726166742D6576656E742D646174610300C70401720206706C617965722A0B7265 +73756C742D6974656DF80004001B707265706172652D736D697468696E672D6576656E742D6461 +74610300C90401720306706C617965722A097265636970652D6964730963616E63656C6C65647F +040015736D6974682D6974656D2D6576656E742D646174610300CB0401720306706C617965722A +0A736C6F742D696E6465787D0963616E63656C6C65647F04001774726164652D73656C6563742D +6576656E742D646174610300CD040172030A76656869636C652D69647A09626C6F636B2D706F73 +010963616E63656C6C65647F04002276656869636C652D626C6F636B2D636F6C6C6973696F6E2D +6576656E742D646174610300CF040172020A76656869636C652D69647A0963616E63656C6C6564 +7F04001C76656869636C652D636F6C6C6973696F6E2D6576656E742D646174610300D104017202 +0A76656869636C652D69647A0963616E63656C6C65647F04001976656869636C652D6372656174 +652D6576656E742D646174610300D3040172040A76656869636C652D69647A0664616D61676576 +0B61747461636B65722D6964B3010963616E63656C6C65647F04001976656869636C652D64616D +6167652D6576656E742D646174610300D5040172030A76656869636C652D69647A0B6174746163 +6B65722D6964B3010963616E63656C6C65647F04001A76656869636C652D64657374726F792D65 +76656E742D646174610300D7040172030A76656869636C652D69647A0A656E74657265642D6964 +7A0963616E63656C6C65647F04001876656869636C652D656E7465722D6576656E742D64617461 +0300D9040172030A76656869636C652D69647A12636F6C6C696465642D656E746974792D69647A +0963616E63656C6C65647F04002376656869636C652D656E746974792D636F6C6C6973696F6E2D +6576656E742D646174610300DB040172030A76656869636C652D69647A096578697465642D6964 +7A0963616E63656C6C65647F04001776656869636C652D657869742D6576656E742D6461746103 +00DD040172040A76656869636C652D69647A0D66726F6D2D706F736974696F6E070B746F2D706F +736974696F6E070963616E63656C6C65647F04001776656869636C652D6D6F76652D6576656E74 +2D646174610300DF040172020A76656869636C652D69647A0963616E63656C6C65647F04001976 +656869636C652D7570646174652D6576656E742D646174610300E10401720304636F73747A0E65 +6E6368616E746D656E742D69647A11656E6368616E746D656E742D6C6576656C7A040011656E63 +68616E746D656E742D6F666665720300E3040170E40401720506706C617965722A046974656DE5 +00066F6666657273E5040F626F6F6B7368656C662D636F756E747A0963616E63656C6C65647F04 +001F707265706172652D6974656D2D656E6368616E742D6576656E742D646174610300E6040172 +020B656E6368616E746D656E740D056C6576656C79040011656E6368616E746D656E742D76616C +75650300E8040170E90401720606706C617965722A046974656DE500066F7074696F6E7A04636F +73747A13656E6368616E746D656E74732D746F2D616464EA040963616E63656C6C65647F040017 +656E6368616E742D6974656D2D6576656E742D646174610300EB0401720308706F736974696F6E +070969732D6566666563747F0963616E63656C6C65647F04001B6C696768746E696E672D737472 +696B652D6576656E742D646174610300ED04016D910211706C617965722D6A6F696E2D6576656E +7412706C617965722D6C656176652D6576656E7412706C617965722D6C6F67696E2D6576656E74 +11706C617965722D636861742D6576656E7419706C617965722D636F6D6D616E642D73656E642D +6576656E741D706C617965722D7065726D697373696F6E2D636865636B2D6576656E7411706C61 +7965722D6D6F76652D6576656E7415706C617965722D74656C65706F72742D6576656E7419706C +617965722D6368616E67652D776F726C642D6576656E7414706C617965722D7265737061776E2D +6576656E7417706C617965722D6578702D6368616E67652D6576656E7416706C617965722D6974 +656D2D68656C642D6576656E741E706C617965722D6368616E6765642D6D61696E2D68616E642D +6576656E741C706C617965722D67616D656D6F64652D6368616E67652D6576656E741B706C6179 +65722D637573746F6D2D7061796C6F61642D6576656E7411706C617965722D666973682D657665 +6E7416706C617965722D6567672D7468726F772D6576656E7424706C617965722D696E74657261 +63742D756E6B6E6F776E2D656E746974792D6576656E741C706C617965722D696E746572616374 +2D656E746974792D6576656E7415706C617965722D696E7465726163742D6576656E7419706C61 +7965722D746F67676C652D736E65616B2D6576656E741A706C617965722D746F67676C652D666C +696768742D6576656E741A706C617965722D746F67676C652D737072696E742D6576656E741569 +6E76656E746F72792D636C69636B2D6576656E7415696E76656E746F72792D636C6F73652D6576 +656E7414626C6F636B2D72656473746F6E652D6576656E7411626C6F636B2D627265616B2D6576 +656E7410626C6F636B2D6275726E2D6576656E7415626C6F636B2D63616E2D6275696C642D6576 +656E7410626C6F636B2D67726F772D6576656E7411626C6F636B2D706C6163652D6576656E741B +626564726F636B2D666F726D2D726573706F6E73652D6576656E74196469616C6F672D636C6963 +6B2D616374696F6E2D6576656E74116469616C6F672D73686F772D6576656E74126469616C6F67 +2D636C6561722D6576656E74147365727665722D636F6D6D616E642D6576656E74167365727665 +722D6C6973742D70696E672D6576656E74117365727665722D6C6F61642D6576656E7412737061 +776E2D6368616E67652D6576656E74167365727665722D62726F6164636173742D6576656E7417 +7365727665722D7469636B2D73746172742D6576656E74157365727665722D7469636B2D656E64 +2D6576656E74157061636B65742D72656365697665642D6576656E74117061636B65742D73656E +742D6576656E74106368756E6B2D6C6F61642D6576656E74106368756E6B2D736176652D657665 +6E74106368756E6B2D73656E642D6576656E7413656E746974792D64616D6167652D6576656E74 +12656E746974792D64656174682D6576656E7412706C617965722D64656174682D6576656E7412 +656E746974792D737061776E2D6576656E7414656E746974792D636F6D627573742D6576656E74 +1A656E746974792D72656761696E2D6865616C74682D6576656E7417656E746974792D6169722D +6368616E67652D6576656E7412656E746974792D62726565642D6576656E7415656E746974792D +6469736D6F756E742D6576656E7410656E746974792D6479652D6576656E741C656E746974792D +656E7465722D6C6F76652D6D6F64652D6576656E7414656E746974792D6578706C6F64652D6576 +656E7412656E746974792D6D6F756E742D6576656E7418656E746974792D7069636B75702D6974 +656D2D6576656E7413656E746974792D706F7274616C2D6576656E7416656E746974792D726573 +7572726563742D6576656E7416656E746974792D73686F6F742D626F772D6576656E7411656E74 +6974792D74616D652D6576656E7413656E746974792D7461726765742D6576656E7415656E7469 +74792D74656C65706F72742D6576656E7419656E746974792D746F67676C652D676C6964652D65 +76656E7416656E746974792D7472616E73666F726D2D6576656E7419706C617965722D6974656D +2D636F6E73756D652D6576656E7418706C617965722D6974656D2D64616D6167652D6576656E74 +16706C617965722D64726F702D6974656D2D6576656E7416706C617965722D6265642D656E7465 +722D6576656E7416706C617965722D6265642D6C656176652D6576656E7419706C617965722D62 +75636B65742D656D7074792D6576656E7418706C617965722D6275636B65742D66696C6C2D6576 +656E7412626C6F636B2D64616D6167652D6576656E7412626C6F636B2D69676E6974652D657665 +6E7413626C6F636B2D66726F6D2D746F2D6576656E7410626C6F636B2D666F726D2D6576656E74 +10626C6F636B2D666164652D6576656E7414626C6F636B2D64697370656E73652D6576656E7413 +626C6F636B2D6578706C6F64652D6576656E7413626C6F636B2D706879736963732D6576656E74 +19626C6F636B2D706973746F6E2D657874656E642D6576656E741A626C6F636B2D706973746F6E +2D726574726163742D6576656E740F6E6F74652D706C61792D6576656E74117369676E2D636861 +6E67652D6576656E741373706F6E67652D6162736F72622D6576656E740F746E742D7072696D65 +2D6576656E7414776561746865722D6368616E67652D6576656E74147468756E6465722D636861 +6E67652D6576656E7410776F726C642D6C6F61642D6576656E7412776F726C642D756E6C6F6164 +2D6576656E741E6173796E632D7374727563747572652D67656E65726174652D6576656E741B61 +73796E632D7374727563747572652D737061776E2D6576656E74146368756E6B2D706F70756C61 +74652D6576656E74126368756E6B2D756E6C6F61642D6576656E7413656E7469746965732D6C6F +61642D6576656E7415656E7469746965732D756E6C6F61642D6576656E741267656E657269632D +67616D652D6576656E74136C6F6F742D67656E65726174652D6576656E7413706F7274616C2D63 +72656174652D6576656E74147374727563747572652D67726F772D6576656E740F74696D652D73 +6B69702D6576656E7410776F726C642D696E69742D6576656E7410776F726C642D736176652D65 +76656E7414696E76656E746F72792D6F70656E2D6576656E7414696E76656E746F72792D647261 +672D6576656E741063726166742D6974656D2D6576656E74136675726E6163652D736D656C742D +6576656E740A627265772D6576656E741862726577696E672D7374616E642D6675656C2D657665 +6E74126675726E6163652D6275726E2D6576656E74156675726E6163652D657874726163742D65 +76656E74196675726E6163652D73746172742D736D656C742D6576656E741D686F707065722D69 +6E76656E746F72792D7365617263682D6576656E7418696E76656E746F72792D63726561746976 +652D6576656E7418696E76656E746F72792D696E7465726163742D6576656E7419696E76656E74 +6F72792D6D6F76652D6974656D2D6576656E741B696E76656E746F72792D7069636B75702D6974 +656D2D6576656E7413707265706172652D616E76696C2D6576656E7418707265706172652D6772 +696E6473746F6E652D6576656E741E707265706172652D696E76656E746F72792D726573756C74 +2D6576656E7418707265706172652D6974656D2D63726166742D6576656E741670726570617265 +2D736D697468696E672D6576656E7410736D6974682D6974656D2D6576656E741274726164652D +73656C6563742D6576656E741D76656869636C652D626C6F636B2D636F6C6C6973696F6E2D6576 +656E741776656869636C652D636F6C6C6973696F6E2D6576656E741476656869636C652D637265 +6174652D6576656E741476656869636C652D64616D6167652D6576656E741576656869636C652D +64657374726F792D6576656E741376656869636C652D656E7465722D6576656E741E7665686963 +6C652D656E746974792D636F6C6C6973696F6E2D6576656E741276656869636C652D657869742D +6576656E741276656869636C652D6D6F76652D6576656E741476656869636C652D757064617465 +2D6576656E741A707265706172652D6974656D2D656E6368616E742D6576656E7412656E636861 +6E742D6974656D2D6576656E74146D61702D696E697469616C697A652D6576656E741368616E67 +696E672D627265616B2D6576656E741D68616E67696E672D627265616B2D62792D656E74697479 +2D6576656E741368616E67696E672D706C6163652D6576656E741362656C6C2D7265736F6E6174 +652D6576656E740F62656C6C2D72696E672D6576656E7411626C6F636B2D62727573682D657665 +6E7410626C6F636B2D636F6F6B2D6576656E7418626C6F636B2D64616D6167652D61626F72742D +6576656E741A626C6F636B2D64697370656E73652D61726D6F722D6576656E7419626C6F636B2D +64697370656E73652D6C6F6F742D6576656E7415626C6F636B2D64726F702D6974656D2D657665 +6E740F626C6F636B2D6578702D6576656E7415626C6F636B2D66657274696C697A652D6576656E +7417626C6F636B2D6D756C74692D706C6163652D6576656E7418626C6F636B2D72656365697665 +2D67616D652D6576656E7418626C6F636B2D73686561722D656E746974792D6576656E7412626C +6F636B2D7370726561642D6576656E741362726577696E672D73746172742D6576656E74146361 +6D70666972652D73746172742D6576656E741B6361756C64726F6E2D6C6576656C2D6368616E67 +652D6576656E7413637261667465722D63726166742D6576656E7417656E746974792D626C6F63 +6B2D666F726D2D6576656E7418666C7569642D6C6576656C2D6368616E67652D6576656E741B69 +6E76656E746F72792D626C6F636B2D73746172742D6576656E74126C65617665732D6465636179 +2D6576656E74156D6F6973747572652D6368616E67652D6576656E74117363756C6B2D626C6F6F +6D2D6576656E74187661756C742D646973706C61792D6974656D2D6576656E7414637265617475 +72652D737061776E2D6576656E741F656E6465722D647261676F6E2D6368616E67652D70686173 +652D6576656E7417656E746974792D627265616B2D646F6F722D6576656E7419656E746974792D +6368616E67652D626C6F636B2D6576656E741C656E746974792D64616D6167652D62792D626C6F +636B2D6576656E741D656E746974792D64616D6167652D62792D656E746974792D6576656E7416 +656E746974792D64726F702D6974656D2D6576656E7418656E746974792D656E7465722D626C6F +636B2D6576656E7417656E746974792D65786861757374696F6E2D6576656E7415656E74697479 +2D696E7465726163742D6576656E7416656E746974792D6B6E6F636B6261636B2D6576656E7412 +656E746974792D706C6163652D6576656E7418656E746974792D706F73652D6368616E67652D65 +76656E741A656E746974792D706F74696F6E2D6566666563742D6576656E7417656E746974792D +7370656C6C2D636173742D6576656E7421656E746974792D7461726765742D6C6976696E672D65 +6E746974792D6576656E7418656E746974792D746F67676C652D7377696D2D6576656E74156578 +706C6F73696F6E2D7072696D652D6576656E741666697265776F726B2D6578706C6F64652D6576 +656E7417666F6F642D6C6576656C2D6368616E67652D6576656E74126974656D2D646573706177 +6E2D6576656E74106974656D2D6D657267652D6576656E74106974656D2D737061776E2D657665 +6E74137069676C696E2D6261727465722D6576656E741470726F6A656374696C652D6869742D65 +76656E741770726F6A656374696C652D6C61756E63682D6576656E741473686565702D6479652D +776F6F6C2D6576656E741773686565702D726567726F772D776F6F6C2D6576656E7411736C696D +652D73706C69742D6576656E7420737472696465722D74656D70657261747572652D6368616E67 +652D6576656E741C76696C6C616765722D616371756972652D74726164652D6576656E741C7669 +6C6C616765722D6361726565722D6368616E67652D6576656E741E76696C6C616765722D726570 +6C656E6973682D74726164652D6576656E741977617264656E2D616E6765722D6368616E67652D +6576656E741D617265612D6566666563742D636C6F75642D6170706C792D6576656E741D617272 +6F772D626F64792D636F756E742D6368616E67652D6576656E74166261742D746F67676C652D73 +6C6565702D6576656E7413637265657065722D706F7765722D6576656E741D656E746974792D63 +6F6D627573742D62792D626C6F636B2D6576656E741E656E746974792D636F6D627573742D6279 +2D656E746974792D6576656E7420656E746974792D6B6E6F636B6261636B2D62792D656E746974 +792D6576656E7419656E746974792D706F7274616C2D656E7465722D6576656E7418656E746974 +792D706F7274616C2D657869742D6576656E7413656E746974792D72656D6F76652D6576656E74 +19656E746974792D7461726765742D626C6F636B2D6576656E7414656E746974792D756E6C6561 +73682D6576656E74106578702D626F74746C652D6576656E7410686F7273652D6A756D702D6576 +656E741D6C696E676572696E672D706F74696F6E2D73706C6173682D6576656E740D7069672D7A +61702D6576656E74167069672D7A6F6D6269652D616E6765722D6576656E7413706F74696F6E2D +73706C6173682D6576656E7413737061776E65722D737061776E2D6576656E7419747269616C2D +737061776E65722D737061776E2D6576656E742076696C6C616765722D72657075746174696F6E +2D6368616E67652D6576656E74176173796E632D706C617965722D636861742D6576656E741C61 +73796E632D706C617965722D7072652D6C6F67696E2D6576656E741D706C617965722D61647661 +6E63656D656E742D646F6E652D6576656E7416706C617965722D616E696D6174696F6E2D657665 +6E7423706C617965722D61726D6F722D7374616E642D6D616E6970756C6174652D6576656E741A +706C617965722D6275636B65742D656E746974792D6576656E741A706C617965722D6368616E67 +65642D776F726C642D6576656E7414706C617965722D6368616E6E656C2D6576656E741F706C61 +7965722D636F6D6D616E642D70726570726F636573732D6576656E7416706C617965722D656469 +742D626F6F6B2D6576656E7419706C617965722D656C797472612D626F6F73742D6576656E7420 +706C617965722D6578702D636F6F6C646F776E2D6368616E67652D6576656E741A706C61796572 +2D686172766573742D626C6F636B2D6576656E7418706C617965722D686964652D656E74697479 +2D6576656E7417706C617965722D6974656D2D627265616B2D6576656E7416706C617965722D69 +74656D2D6D656E642D6576656E7411706C617965722D6B69636B2D6576656E7419706C61796572 +2D6C656173682D656E746974792D6576656E7419706C617965722D6C6576656C2D6368616E6765 +2D6576656E741A706C617965722D6C6F63616C652D6368616E67652D6576656E7418706C617965 +722D6E616D652D656E746974792D6576656E7416706C617965722D6F70656E2D7369676E2D6576 +656E7413706C617965722D706F7274616C2D6576656E7416706C617965722D7072652D6C6F6769 +6E2D6576656E7414706C617965722D726970746964652D6576656E7419706C617965722D736865 +61722D656E746974792D6576656E7418706C617965722D73686F772D656E746974792D6576656E +7419706C617965722D737061776E2D6368616E67652D6576656E7420706C617965722D73746174 +69737469632D696E6372656D656E742D6576656E7417706C617965722D737761702D68616E6473 +2D6576656E741E706C617965722D74616B652D6C65637465726E2D626F6F6B2D6576656E741B70 +6C617965722D756E6C656173682D656E746974792D6576656E7415706C617965722D76656C6F63 +6974792D6576656E7412706C617965722D696E7075742D6576656E741F706C617965722D696E74 +65726163742D61742D656E746974792D6576656E7417706C617965722D6C696E6B732D73656E64 +2D6576656E7419706C617965722D7069636B75702D6172726F772D6576656E741E706C61796572 +2D7265636970652D626F6F6B2D636C69636B2D6576656E7428706C617965722D7265636970652D +626F6F6B2D73657474696E67732D6368616E67652D6576656E741C706C617965722D7265636970 +652D646973636F7665722D6576656E741D706C617965722D72656769737465722D6368616E6E65 +6C2D6576656E7421706C617965722D7265736F757263652D7061636B2D7374617475732D657665 +6E741B706C617965722D737061776E2D6C6F636174696F6E2D6576656E741F706C617965722D75 +6E72656769737465722D6368616E6E656C2D6576656E7411726169642D66696E6973682D657665 +6E7415726169642D737061776E2D776176652D6576656E740F726169642D73746F702D6576656E +7412726169642D747269676765722D6576656E74166C696768746E696E672D737472696B652D65 +76656E7404000A6576656E742D747970650300EF040171910211706C617965722D6A6F696E2D65 +76656E74012D0012706C617965722D6C656176652D6576656E74012F0012706C617965722D6C6F +67696E2D6576656E7401310011706C617965722D636861742D6576656E7401360019706C617965 +722D636F6D6D616E642D73656E642D6576656E740138001D706C617965722D7065726D69737369 +6F6E2D636865636B2D6576656E74013A0011706C617965722D6D6F76652D6576656E74013C0015 +706C617965722D74656C65706F72742D6576656E74013E0019706C617965722D6368616E67652D +776F726C642D6576656E7401C1000014706C617965722D7265737061776E2D6576656E7401C300 +0017706C617965722D6578702D6368616E67652D6576656E7401C5000016706C617965722D6974 +656D2D68656C642D6576656E7401C700001E706C617965722D6368616E6765642D6D61696E2D68 +616E642D6576656E7401C900001C706C617965722D67616D656D6F64652D6368616E67652D6576 +656E7401CB00001B706C617965722D637573746F6D2D7061796C6F61642D6576656E7401CD0000 +11706C617965722D666973682D6576656E7401D2000016706C617965722D6567672D7468726F77 +2D6576656E7401D4000024706C617965722D696E7465726163742D756E6B6E6F776E2D656E7469 +74792D6576656E7401E300001C706C617965722D696E7465726163742D656E746974792D657665 +6E740198010015706C617965722D696E7465726163742D6576656E7401DB000019706C61796572 +2D746F67676C652D736E65616B2D6576656E7401DD00001A706C617965722D746F67676C652D66 +6C696768742D6576656E7401DF00001A706C617965722D746F67676C652D737072696E742D6576 +656E7401E1000015696E76656E746F72792D636C69636B2D6576656E7401E8000015696E76656E +746F72792D636C6F73652D6576656E7401EA000014626C6F636B2D72656473746F6E652D657665 +6E7401EC000011626C6F636B2D627265616B2D6576656E7401EF000010626C6F636B2D6275726E +2D6576656E7401F1000015626C6F636B2D63616E2D6275696C642D6576656E7401F3000010626C +6F636B2D67726F772D6576656E7401F5000011626C6F636B2D706C6163652D6576656E7401F700 +00196469616C6F672D636C69636B2D616374696F6E2D6576656E7401FC0000116469616C6F672D +73686F772D6576656E7401FE0000126469616C6F672D636C6561722D6576656E74018001001B62 +6564726F636B2D666F726D2D726573706F6E73652D6576656E7401FA0000147365727665722D63 +6F6D6D616E642D6576656E7401820100167365727665722D6C6973742D70696E672D6576656E74 +01860100117365727665722D6C6F61642D6576656E74018A010012737061776E2D6368616E6765 +2D6576656E74018C0100167365727665722D62726F6164636173742D6576656E74018E01001773 +65727665722D7469636B2D73746172742D6576656E7401900100157365727665722D7469636B2D +656E642D6576656E7401920100157061636B65742D72656365697665642D6576656E7401940100 +117061636B65742D73656E742D6576656E7401960100106368756E6B2D6C6F61642D6576656E74 +019A0100106368756E6B2D736176652D6576656E74019C0100106368756E6B2D73656E642D6576 +656E74019E010013656E746974792D64616D6167652D6576656E7401A0010012656E746974792D +64656174682D6576656E7401A2010012706C617965722D64656174682D6576656E7401A4010012 +656E746974792D737061776E2D6576656E7401A6010014656E746974792D636F6D627573742D65 +76656E7401A801001A656E746974792D72656761696E2D6865616C74682D6576656E7401AA0100 +17656E746974792D6169722D6368616E67652D6576656E7401AC010012656E746974792D627265 +65642D6576656E7401AE010015656E746974792D6469736D6F756E742D6576656E7401B0010010 +656E746974792D6479652D6576656E7401B201001C656E746974792D656E7465722D6C6F76652D +6D6F64652D6576656E7401B5010014656E746974792D6578706C6F64652D6576656E7401B70100 +12656E746974792D6D6F756E742D6576656E7401B9010018656E746974792D7069636B75702D69 +74656D2D6576656E7401BB010013656E746974792D706F7274616C2D6576656E7401BD01001665 +6E746974792D7265737572726563742D6576656E7401BF010016656E746974792D73686F6F742D +626F772D6576656E7401C1010011656E746974792D74616D652D6576656E7401C3010013656E74 +6974792D7461726765742D6576656E7401C5010015656E746974792D74656C65706F72742D6576 +656E7401C7010019656E746974792D746F67676C652D676C6964652D6576656E7401C901001665 +6E746974792D7472616E73666F726D2D6576656E7401CB010019706C617965722D6974656D2D63 +6F6E73756D652D6576656E7401BD020018706C617965722D6974656D2D64616D6167652D657665 +6E7401BF020016706C617965722D64726F702D6974656D2D6576656E7401C1020016706C617965 +722D6265642D656E7465722D6576656E7401C3020016706C617965722D6265642D6C656176652D +6576656E7401C5020019706C617965722D6275636B65742D656D7074792D6576656E7401C70200 +18706C617965722D6275636B65742D66696C6C2D6576656E7401C9020012626C6F636B2D64616D +6167652D6576656E7401AC030012626C6F636B2D69676E6974652D6576656E7401AE030013626C +6F636B2D66726F6D2D746F2D6576656E7401B0030010626C6F636B2D666F726D2D6576656E7401 +B2030010626C6F636B2D666164652D6576656E7401B4030014626C6F636B2D64697370656E7365 +2D6576656E7401B6030013626C6F636B2D6578706C6F64652D6576656E7401B8030013626C6F63 +6B2D706879736963732D6576656E7401BA030019626C6F636B2D706973746F6E2D657874656E64 +2D6576656E7401BC03001A626C6F636B2D706973746F6E2D726574726163742D6576656E7401BE +03000F6E6F74652D706C61792D6576656E7401C00300117369676E2D6368616E67652D6576656E +7401C203001373706F6E67652D6162736F72622D6576656E7401C403000F746E742D7072696D65 +2D6576656E7401C6030014776561746865722D6368616E67652D6576656E740184040014746875 +6E6465722D6368616E67652D6576656E740186040010776F726C642D6C6F61642D6576656E7401 +88040012776F726C642D756E6C6F61642D6576656E74018A04001E6173796E632D737472756374 +7572652D67656E65726174652D6576656E74018C04001B6173796E632D7374727563747572652D +737061776E2D6576656E74018E0400146368756E6B2D706F70756C6174652D6576656E74019004 +00126368756E6B2D756E6C6F61642D6576656E740192040013656E7469746965732D6C6F61642D +6576656E740194040015656E7469746965732D756E6C6F61642D6576656E74019604001267656E +657269632D67616D652D6576656E7401980400136C6F6F742D67656E65726174652D6576656E74 +019A040013706F7274616C2D6372656174652D6576656E74019C0400147374727563747572652D +67726F772D6576656E74019E04000F74696D652D736B69702D6576656E7401A0040010776F726C +642D696E69742D6576656E7401A2040010776F726C642D736176652D6576656E7401A404001469 +6E76656E746F72792D6F70656E2D6576656E7401A6040014696E76656E746F72792D647261672D +6576656E7401A804001063726166742D6974656D2D6576656E7401AA0400136675726E6163652D +736D656C742D6576656E7401AC04000A627265772D6576656E7401AE04001862726577696E672D +7374616E642D6675656C2D6576656E7401B00400126675726E6163652D6275726E2D6576656E74 +01B20400156675726E6163652D657874726163742D6576656E7401B40400196675726E6163652D +73746172742D736D656C742D6576656E7401B604001D686F707065722D696E76656E746F72792D +7365617263682D6576656E7401B8040018696E76656E746F72792D63726561746976652D657665 +6E7401BA040018696E76656E746F72792D696E7465726163742D6576656E7401BC040019696E76 +656E746F72792D6D6F76652D6974656D2D6576656E7401BE04001B696E76656E746F72792D7069 +636B75702D6974656D2D6576656E7401C0040013707265706172652D616E76696C2D6576656E74 +01C2040018707265706172652D6772696E6473746F6E652D6576656E7401C404001E7072657061 +72652D696E76656E746F72792D726573756C742D6576656E7401C6040018707265706172652D69 +74656D2D63726166742D6576656E7401C8040016707265706172652D736D697468696E672D6576 +656E7401CA040010736D6974682D6974656D2D6576656E7401CC04001274726164652D73656C65 +63742D6576656E7401CE04001D76656869636C652D626C6F636B2D636F6C6C6973696F6E2D6576 +656E7401D004001776656869636C652D636F6C6C6973696F6E2D6576656E7401D2040014766568 +69636C652D6372656174652D6576656E7401D404001476656869636C652D64616D6167652D6576 +656E7401D604001576656869636C652D64657374726F792D6576656E7401D80400137665686963 +6C652D656E7465722D6576656E7401DA04001E76656869636C652D656E746974792D636F6C6C69 +73696F6E2D6576656E7401DC04001276656869636C652D657869742D6576656E7401DE04001276 +656869636C652D6D6F76652D6576656E7401E004001476656869636C652D7570646174652D6576 +656E7401E204001A707265706172652D6974656D2D656E6368616E742D6576656E7401E7040012 +656E6368616E742D6974656D2D6576656E7401EC0400146D61702D696E697469616C697A652D65 +76656E7401C803001368616E67696E672D627265616B2D6576656E7401CA03001D68616E67696E +672D627265616B2D62792D656E746974792D6576656E7401CC03001368616E67696E672D706C61 +63652D6576656E7401CE03001362656C6C2D7265736F6E6174652D6576656E7401D003000F6265 +6C6C2D72696E672D6576656E7401D2030011626C6F636B2D62727573682D6576656E7401D40300 +10626C6F636B2D636F6F6B2D6576656E7401D6030018626C6F636B2D64616D6167652D61626F72 +742D6576656E7401D803001A626C6F636B2D64697370656E73652D61726D6F722D6576656E7401 +DA030019626C6F636B2D64697370656E73652D6C6F6F742D6576656E7401DC030015626C6F636B +2D64726F702D6974656D2D6576656E7401DE03000F626C6F636B2D6578702D6576656E7401E003 +0015626C6F636B2D66657274696C697A652D6576656E7401E4030017626C6F636B2D6D756C7469 +2D706C6163652D6576656E7401E6030018626C6F636B2D726563656976652D67616D652D657665 +6E7401E8030018626C6F636B2D73686561722D656E746974792D6576656E7401EA030012626C6F +636B2D7370726561642D6576656E7401EC03001362726577696E672D73746172742D6576656E74 +01EE03001463616D70666972652D73746172742D6576656E7401F003001B6361756C64726F6E2D +6C6576656C2D6368616E67652D6576656E7401F2030013637261667465722D63726166742D6576 +656E7401F4030017656E746974792D626C6F636B2D666F726D2D6576656E7401F6030018666C75 +69642D6C6576656C2D6368616E67652D6576656E7401F803001B696E76656E746F72792D626C6F +636B2D73746172742D6576656E7401FA0300126C65617665732D64656361792D6576656E7401FC +0300156D6F6973747572652D6368616E67652D6576656E7401FE0300117363756C6B2D626C6F6F +6D2D6576656E7401800400187661756C742D646973706C61792D6974656D2D6576656E74018204 +001463726561747572652D737061776E2D6576656E7401CD01001F656E6465722D647261676F6E +2D6368616E67652D70686173652D6576656E7401CF010017656E746974792D627265616B2D646F +6F722D6576656E7401D1010019656E746974792D6368616E67652D626C6F636B2D6576656E7401 +D301001C656E746974792D64616D6167652D62792D626C6F636B2D6576656E7401D501001D656E +746974792D64616D6167652D62792D656E746974792D6576656E7401D7010016656E746974792D +64726F702D6974656D2D6576656E7401D9010018656E746974792D656E7465722D626C6F636B2D +6576656E7401DB010017656E746974792D65786861757374696F6E2D6576656E7401DD01001565 +6E746974792D696E7465726163742D6576656E7401DF010016656E746974792D6B6E6F636B6261 +636B2D6576656E7401E1010012656E746974792D706C6163652D6576656E7401E3010018656E74 +6974792D706F73652D6368616E67652D6576656E7401E501001A656E746974792D706F74696F6E +2D6566666563742D6576656E7401E7010017656E746974792D7370656C6C2D636173742D657665 +6E7401E9010021656E746974792D7461726765742D6C6976696E672D656E746974792D6576656E +7401EB010018656E746974792D746F67676C652D7377696D2D6576656E7401ED0100156578706C +6F73696F6E2D7072696D652D6576656E7401EF01001666697265776F726B2D6578706C6F64652D +6576656E7401F1010017666F6F642D6C6576656C2D6368616E67652D6576656E7401F301001269 +74656D2D6465737061776E2D6576656E7401F50100106974656D2D6D657267652D6576656E7401 +F70100106974656D2D737061776E2D6576656E7401F90100137069676C696E2D6261727465722D +6576656E7401FC01001470726F6A656374696C652D6869742D6576656E7401FE01001770726F6A +656374696C652D6C61756E63682D6576656E74018002001473686565702D6479652D776F6F6C2D +6576656E74018202001773686565702D726567726F772D776F6F6C2D6576656E74018402001173 +6C696D652D73706C69742D6576656E740186020020737472696465722D74656D70657261747572 +652D6368616E67652D6576656E74018802001C76696C6C616765722D616371756972652D747261 +64652D6576656E74018A02001C76696C6C616765722D6361726565722D6368616E67652D657665 +6E74018C02001E76696C6C616765722D7265706C656E6973682D74726164652D6576656E74018E +02001977617264656E2D616E6765722D6368616E67652D6576656E74019002001D617265612D65 +66666563742D636C6F75642D6170706C792D6576656E74019302001D6172726F772D626F64792D +636F756E742D6368616E67652D6576656E7401950200166261742D746F67676C652D736C656570 +2D6576656E740197020013637265657065722D706F7765722D6576656E74019902001D656E7469 +74792D636F6D627573742D62792D626C6F636B2D6576656E74019B02001E656E746974792D636F +6D627573742D62792D656E746974792D6576656E74019D020020656E746974792D6B6E6F636B62 +61636B2D62792D656E746974792D6576656E74019F020019656E746974792D706F7274616C2D65 +6E7465722D6576656E7401A1020018656E746974792D706F7274616C2D657869742D6576656E74 +01A3020013656E746974792D72656D6F76652D6576656E7401A5020019656E746974792D746172 +6765742D626C6F636B2D6576656E7401A7020014656E746974792D756E6C656173682D6576656E +7401A90200106578702D626F74746C652D6576656E7401AB020010686F7273652D6A756D702D65 +76656E7401AD02001D6C696E676572696E672D706F74696F6E2D73706C6173682D6576656E7401 +AF02000D7069672D7A61702D6576656E7401B10200167069672D7A6F6D6269652D616E6765722D +6576656E7401B3020013706F74696F6E2D73706C6173682D6576656E7401B5020013737061776E +65722D737061776E2D6576656E7401B7020019747269616C2D737061776E65722D737061776E2D +6576656E7401B902002076696C6C616765722D72657075746174696F6E2D6368616E67652D6576 +656E7401BB0200176173796E632D706C617965722D636861742D6576656E7401CB02001C617379 +6E632D706C617965722D7072652D6C6F67696E2D6576656E7401CD02001D706C617965722D6164 +76616E63656D656E742D646F6E652D6576656E7401CF020016706C617965722D616E696D617469 +6F6E2D6576656E7401D1020023706C617965722D61726D6F722D7374616E642D6D616E6970756C +6174652D6576656E7401D302001A706C617965722D6275636B65742D656E746974792D6576656E +7401D502001A706C617965722D6368616E6765642D776F726C642D6576656E7401D7020014706C +617965722D6368616E6E656C2D6576656E7401D902001F706C617965722D636F6D6D616E642D70 +726570726F636573732D6576656E7401DB020016706C617965722D656469742D626F6F6B2D6576 +656E7401DE020019706C617965722D656C797472612D626F6F73742D6576656E7401E002002070 +6C617965722D6578702D636F6F6C646F776E2D6368616E67652D6576656E7401E202001A706C61 +7965722D686172766573742D626C6F636B2D6576656E7401E4020018706C617965722D68696465 +2D656E746974792D6576656E7401E6020017706C617965722D6974656D2D627265616B2D657665 +6E7401E8020016706C617965722D6974656D2D6D656E642D6576656E7401EA020011706C617965 +722D6B69636B2D6576656E7401EC020019706C617965722D6C656173682D656E746974792D6576 +656E7401EE020019706C617965722D6C6576656C2D6368616E67652D6576656E7401F002001A70 +6C617965722D6C6F63616C652D6368616E67652D6576656E7401F2020018706C617965722D6E61 +6D652D656E746974792D6576656E7401F4020016706C617965722D6F70656E2D7369676E2D6576 +656E7401F6020013706C617965722D706F7274616C2D6576656E7401F8020016706C617965722D +7072652D6C6F67696E2D6576656E7401FA020014706C617965722D726970746964652D6576656E +7401FC020019706C617965722D73686561722D656E746974792D6576656E7401FE020018706C61 +7965722D73686F772D656E746974792D6576656E740180030019706C617965722D737061776E2D +6368616E67652D6576656E740182030020706C617965722D7374617469737469632D696E637265 +6D656E742D6576656E740184030017706C617965722D737761702D68616E64732D6576656E7401 +8603001E706C617965722D74616B652D6C65637465726E2D626F6F6B2D6576656E74018803001B +706C617965722D756E6C656173682D656E746974792D6576656E74018A030015706C617965722D +76656C6F636974792D6576656E74018C030012706C617965722D696E7075742D6576656E74018E +03001F706C617965722D696E7465726163742D61742D656E746974792D6576656E740190030017 +706C617965722D6C696E6B732D73656E642D6576656E740192030019706C617965722D7069636B +75702D6172726F772D6576656E74019403001E706C617965722D7265636970652D626F6F6B2D63 +6C69636B2D6576656E740196030028706C617965722D7265636970652D626F6F6B2D7365747469 +6E67732D6368616E67652D6576656E74019803001C706C617965722D7265636970652D64697363 +6F7665722D6576656E74019A03001D706C617965722D72656769737465722D6368616E6E656C2D +6576656E74019C030021706C617965722D7265736F757263652D7061636B2D7374617475732D65 +76656E74019E03001B706C617965722D737061776E2D6C6F636174696F6E2D6576656E7401A003 +001F706C617965722D756E72656769737465722D6368616E6E656C2D6576656E7401A203001172 +6169642D66696E6973682D6576656E7401A4030015726169642D737061776E2D776176652D6576 +656E7401A603000F726169642D73746F702D6576656E7401A8030012726169642D747269676765 +722D6576656E7401AA0300166C696768746E696E672D737472696B652D6576656E7401EE040004 +00056576656E740300F10403001A70756D706B696E3A706C7567696E2F6576656E7440302E312E +300568020300220A6576656E742D74797065020300220E6576656E742D7072696F726974790203 +002107636F6D6D616E64020300140A7065726D697373696F6E01421F0203020163040006736572 +766572030000020302016904000A6576656E742D74797065030002020302016A04000E6576656E +742D7072696F72697479030004020302016B040007636F6D6D616E64030006020302016C04000A +7065726D697373696F6E030008016B7301720A0F6D61726B6574706C6163652D75726C7309706C +7567696E2D6964780B706C7567696E2D6E616D65730776657273696F6E73066465762D69647808 +6465762D6E616D65730769732D706169647F07757365722D6964780B6C6963656E73652D6B6579 +0A096973737565642D6174730400146D61726B6574706C6163652D6D6574616461746103000B04 +0007636F6E74657874030101680D0140050473656C660E0A68616E646C65722D6964790A657665 +6E742D74797065030E6576656E742D7072696F726974790508626C6F636B696E677F010004001E +5B6D6574686F645D636F6E746578742E72656769737465722D6576656E74010F01690701400304 +73656C660E07636F6D6D616E64100A7065726D697373696F6E7301000400205B6D6574686F645D +636F6E746578742E72656769737465722D636F6D6D616E640111016A0001730140020473656C66 +0E0A7065726D697373696F6E0900120400235B6D6574686F645D636F6E746578742E7265676973 +7465722D7065726D697373696F6E01130140010473656C660E007304001F5B6D6574686F645D63 +6F6E746578742E6765742D646174612D666F6C64657201140169010140010473656C660E001504 +001A5B6D6574686F645D636F6E746578742E6765742D7365727665720116016B0C014001047365 +6C660E00170400285B6D6574686F645D636F6E746578742E6765742D6D61726B6574706C616365 +2D6D65746164617461011803001C70756D706B696E3A706C7567696E2F636F6E7465787440302E +312E30056D01420602030201620400066C6F63616C65030000014002036B657973066C6F63616C +650100730400097472616E736C6174650102014003096E616D65737061636573046A736F6E7306 +6C6F63616C650101000400116C6F61642D7472616E736C6174696F6E73010303001970756D706B +696E3A706C7567696E2F6931386E40302E312E30056E0142060140020A68616E646C65722D6964 +790B64656C61792D7469636B737700790400157363686564756C652D64656C617965642D746173 +6B01000140030A68616E646C65722D6964790B64656C61792D7469636B73770C706572696F642D +7469636B737700790400177363686564756C652D726570656174696E672D7461736B0101014001 +077461736B2D696479010004000B63616E63656C2D7461736B010203001E70756D706B696E3A70 +6C7567696E2F7363686564756C657240302E312E30056F020300130D6C6976696E672D656E7469 +747902030013036D6F62020300130E706174682D6E6F64652D7479706502030013096479652D63 +6F6C6F72020300131376696C6C616765722D70726F66657373696F6E02030013086D6F622D6461 +7461020300130A73686565702D646174610203001309776F6C662D646174610203001308636174 +2D64617461020300130D76696C6C616765722D64617461020300130C637265657065722D646174 +61020300130A736C696D652D64617461020300130D656E6465726D616E2D64617461020300130F +69726F6E2D676F6C656D2D646174610203001308666F782D64617461020300130C61676561626C +652D64617461020300130B7A6F6D6269652D64617461020300130C7368756C6B65722D64617461 +020300130E726179636173742D726573756C74020300130F626C6F636B2D646972656374696F6E +01422E0203020141040006656E74697479030000020302017004000D6C6976696E672D656E7469 +747903000202030201710400036D6F62030004020302017204000E706174682D6E6F64652D7479 +706503000602030201730400096479652D636F6C6F72030008020302017404001376696C6C6167 +65722D70726F66657373696F6E03000A02030201750400086D6F622D6461746103000C02030201 +7604000A73686565702D6461746103000E0203020177040009776F6C662D646174610300100203 +0201780400086361742D64617461030012020302017904000D76696C6C616765722D6461746103 +0014020302017A04000C637265657065722D64617461030016020302017B04000A736C696D652D +64617461030018020302017C04000D656E6465726D616E2D6461746103001A020302017D04000F +69726F6E2D676F6C656D2D6461746103001C020302017E040008666F782D6461746103001E0203 +02017F04000C61676561626C652D6461746103002002030201800104000B7A6F6D6269652D6461 +746103002202030201810104000C7368756C6B65722D6461746103002402030201820104000E72 +6179636173742D726573756C7403002602030201420400167261792D74726163652D626C6F636B +2D726573756C7403002802030201430400177261792D74726163652D656E746974792D72657375 +6C7403002A02030201830104000F626C6F636B2D646972656374696F6E03002C03001B70756D70 +6B696E3A706C7567696E2F656E7469747940302E312E3005840101422D020302010804000E7465 +78742D636F6D706F6E656E740300000203020155040006706C61796572030002016D070470696E +6B04626C75650372656405677265656E0679656C6C6F7706707572706C6505776869746504000E +626F73732D6261722D636F6C6F72030004016D050B6E6F2D6469766973696F6E096E6F74636865 +732D360A6E6F74636865732D31300A6E6F74636865732D31320A6E6F74636865732D3230040011 +626F73732D6261722D6469766973696F6E0300060172030A6461726B656E2D736B797F0A647261 +676F6E2D6261727F0A6372656174652D666F677F040011626F73732D6261722D6D657461646174 +61030008040008626F73732D626172030101690101690A014003057469746C650B05636F6C6F72 +05086469766973696F6E07000C0400155B636F6E7374727563746F725D626F73732D626172010D +01680A0140010473656C660E000B04001A5B6D6574686F645D626F73732D6261722E6765742D74 +69746C65010F0140020473656C660E057469746C650B010004001A5B6D6574686F645D626F7373 +2D6261722E7365742D7469746C6501100140010473656C660E007604001B5B6D6574686F645D62 +6F73732D6261722E6765742D6865616C746801110140020473656C660E066865616C7468760100 +04001B5B6D6574686F645D626F73732D6261722E7365742D6865616C746801120140010473656C +660E000504001A5B6D6574686F645D626F73732D6261722E6765742D636F6C6F72011301400204 +73656C660E05636F6C6F7205010004001A5B6D6574686F645D626F73732D6261722E7365742D63 +6F6C6F7201140140010473656C660E000704001D5B6D6574686F645D626F73732D6261722E6765 +742D6469766973696F6E01150140020473656C660E086469766973696F6E07010004001D5B6D65 +74686F645D626F73732D6261722E7365742D6469766973696F6E01160140010473656C660E0009 +04001D5B6D6574686F645D626F73732D6261722E6765742D6D6574616461746101170140020473 +656C660E086D6574616461746109010004001D5B6D6574686F645D626F73732D6261722E736574 +2D6D6574616461746101180169030140020473656C660E06706C6179657219010004001B5B6D65 +74686F645D626F73732D6261722E6164642D706C61796572011A04001E5B6D6574686F645D626F +73732D6261722E72656D6F76652D706C61796572011A0170190140010473656C660E001B04001C +5B6D6574686F645D626F73732D6261722E6765742D706C6179657273011C0140010473656C660E +010004001B5B6D6574686F645D626F73732D6261722E72656D6F76652D616C6C011D03001D7075 +6D706B696E3A706C7567696E2F626F73732D62617240302E312E30058501014208017304000970 +6C7567696E2D696403000001707D04000B6970632D6D657373616765030002016A01030173016A +01040001400209726563697069656E7401076D65737361676503000504001073656E642D697063 +2D6D657373616765010603001870756D706B696E3A706C7567696E2F69706340302E312E300586 +010142A6010203020141040006656E74697479030000020302010804000E746578742D636F6D70 +6F6E656E74030002020302011404000A6974656D2D737461636B03000402030201340400047575 +6964030006016D0405666978656408766572746963616C0A686F72697A6F6E74616C0663656E74 +657204000E62696C6C626F6172642D6D6F6465030008016D09046E6F6E65147468697264706572 +736F6E2D6C65667468616E64157468697264706572736F6E2D726967687468616E641466697273 +74706572736F6E2D6C65667468616E64156669727374706572736F6E2D726967687468616E6404 +68656164036775690667726F756E640566697865640400116974656D2D646973706C61792D6D6F +646503000A016D030663656E746572046C65667405726967687404000E746578742D616C69676E +6D656E7403000C017203017876017976017A76040008766563746F72336603000E017204017876 +017976017A7601777604000B7175617465726E696F6E660300100172040B7472616E736C617469 +6F6E0F057363616C650F0D6C6566742D726F746174696F6E110E72696768742D726F746174696F +6E11040016646973706C61792D7472616E73666F726D6174696F6E03001204000E646973706C61 +792D656E746974790301040014626C6F636B2D646973706C61792D656E74697479030104001369 +74656D2D646973706C61792D656E746974790301040013746578742D646973706C61792D656E74 +6974790301040012696E746572616374696F6E2D656E746974790301016801016914016B1A0140 +0106656E7469747919001B0400225B7374617469635D646973706C61792D656E746974792E6672 +6F6D2D656E74697479011C0168140169010140010473656C661D001E0400215B6D6574686F645D +646973706C61792D656E746974792E6765742D656E74697479011F0140010473656C661D001304 +00295B6D6574686F645D646973706C61792D656E746974792E6765742D7472616E73666F726D61 +74696F6E01200140020473656C661D0E7472616E73666F726D6174696F6E1301000400295B6D65 +74686F645D646973706C61792D656E746974792E7365742D7472616E73666F726D6174696F6E01 +210140010473656C661D007A0400315B6D6574686F645D646973706C61792D656E746974792E67 +65742D696E746572706F6C6174696F6E2D6475726174696F6E01220140020473656C661D086475 +726174696F6E7A01000400315B6D6574686F645D646973706C61792D656E746974792E7365742D +696E746572706F6C6174696F6E2D6475726174696F6E012304002E5B6D6574686F645D64697370 +6C61792D656E746974792E6765742D696E746572706F6C6174696F6E2D73746172740122014002 +0473656C661D0B64656C74612D7469636B737A010004002E5B6D6574686F645D646973706C6179 +2D656E746974792E7365742D696E746572706F6C6174696F6E2D7374617274012404002C5B6D65 +74686F645D646973706C61792D656E746974792E6765742D74656C65706F72742D647572617469 +6F6E012204002C5B6D6574686F645D646973706C61792D656E746974792E7365742D74656C6570 +6F72742D6475726174696F6E01230140010473656C661D00090400245B6D6574686F645D646973 +706C61792D656E746974792E6765742D62696C6C626F61726401250140020473656C661D046D6F +64650901000400245B6D6574686F645D646973706C61792D656E746974792E7365742D62696C6C +626F61726401260140010473656C661D00760400255B6D6574686F645D646973706C61792D656E +746974792E6765742D766965772D72616E676501270140020473656C661D0572616E6765760100 +0400255B6D6574686F645D646973706C61792D656E746974792E7365742D766965772D72616E67 +6501280400285B6D6574686F645D646973706C61792D656E746974792E6765742D736861646F77 +2D72616469757301270140020473656C661D067261646975737601000400285B6D6574686F645D +646973706C61792D656E746974792E7365742D736861646F772D726164697573012904002A5B6D +6574686F645D646973706C61792D656E746974792E6765742D736861646F772D737472656E6774 +6801270140020473656C661D08737472656E67746876010004002A5B6D6574686F645D64697370 +6C61792D656E746974792E7365742D736861646F772D737472656E677468012A0400285B6D6574 +686F645D646973706C61792D656E746974792E6765742D646973706C61792D7769647468012701 +40020473656C661D0577696474687601000400285B6D6574686F645D646973706C61792D656E74 +6974792E7365742D646973706C61792D7769647468012B0400295B6D6574686F645D646973706C +61792D656E746974792E6765742D646973706C61792D68656967687401270140020473656C661D +066865696768747601000400295B6D6574686F645D646973706C61792D656E746974792E736574 +2D646973706C61792D686569676874012C04002E5B6D6574686F645D646973706C61792D656E74 +6974792E6765742D676C6F772D636F6C6F722D6F7665727269646501220140020473656C661D05 +636F6C6F727A010004002E5B6D6574686F645D646973706C61792D656E746974792E7365742D67 +6C6F772D636F6C6F722D6F76657272696465012D0400255B6D6574686F645D646973706C61792D +656E746974792E6765742D6272696768746E65737301220140020473656C661D0A627269676874 +6E6573737A01000400255B6D6574686F645D646973706C61792D656E746974792E7365742D6272 +696768746E657373012E016915016B2F01400106656E746974791900300400285B737461746963 +5D626C6F636B2D646973706C61792D656E746974792E66726F6D2D656E74697479013101681501 +40010473656C6632001A0400285B6D6574686F645D626C6F636B2D646973706C61792D656E7469 +74792E6765742D646973706C617901330140010473656C6632001E0400275B6D6574686F645D62 +6C6F636B2D646973706C61792D656E746974792E6765742D656E7469747901340140010473656C +6632007B04002F5B6D6574686F645D626C6F636B2D646973706C61792D656E746974792E676574 +2D626C6F636B2D73746174652D696401350140020473656C66320873746174652D69647B010004 +002F5B6D6574686F645D626C6F636B2D646973706C61792D656E746974792E7365742D626C6F63 +6B2D73746174652D69640136016916016B3701400106656E746974791900380400275B73746174 +69635D6974656D2D646973706C61792D656E746974792E66726F6D2D656E746974790139016816 +0140010473656C663A001A0400275B6D6574686F645D6974656D2D646973706C61792D656E7469 +74792E6765742D646973706C6179013B0140010473656C663A001E0400265B6D6574686F645D69 +74656D2D646973706C61792D656E746974792E6765742D656E74697479013C016905016B3D0140 +010473656C663A003E0400245B6D6574686F645D6974656D2D646973706C61792D656E74697479 +2E6765742D6974656D013F0140020473656C663A046974656D3E01000400245B6D6574686F645D +6974656D2D646973706C61792D656E746974792E7365742D6974656D01400140010473656C663A +000B0400315B6D6574686F645D6974656D2D646973706C61792D656E746974792E6765742D6974 +656D2D646973706C61792D6D6F646501410140020473656C663A046D6F64650B01000400315B6D +6574686F645D6974656D2D646973706C61792D656E746974792E7365742D6974656D2D64697370 +6C61792D6D6F64650142016917016BC30001400106656E746974791900C4000400275B73746174 +69635D746578742D646973706C61792D656E746974792E66726F6D2D656E746974790145016817 +0140010473656C66C600001A0400275B6D6574686F645D746578742D646973706C61792D656E74 +6974792E6765742D646973706C617901470140010473656C66C600001E0400265B6D6574686F64 +5D746578742D646973706C61792D656E746974792E6765742D656E746974790148016903014001 +0473656C66C60000C9000400245B6D6574686F645D746578742D646973706C61792D656E746974 +792E6765742D74657874014A0140020473656C66C6000474657874C90001000400245B6D657468 +6F645D746578742D646973706C61792D656E746974792E7365742D74657874014B014001047365 +6C66C600007A04002A5B6D6574686F645D746578742D646973706C61792D656E746974792E6765 +742D6C696E652D7769647468014C0140020473656C66C6000577696474687A010004002A5B6D65 +74686F645D746578742D646973706C61792D656E746974792E7365742D6C696E652D7769647468 +014D04002A5B6D6574686F645D746578742D646973706C61792D656E746974792E6765742D6261 +636B67726F756E64014C0140020473656C66C60005636F6C6F727A010004002A5B6D6574686F64 +5D746578742D646973706C61792D656E746974792E7365742D6261636B67726F756E64014E0140 +010473656C66C600007E04002C5B6D6574686F645D746578742D646973706C61792D656E746974 +792E6765742D746578742D6F706163697479014F0140020473656C66C600076F7061636974797E +010004002C5B6D6574686F645D746578742D646973706C61792D656E746974792E7365742D7465 +78742D6F70616369747901500140010473656C66C600007F0400265B6D6574686F645D74657874 +2D646973706C61792D656E746974792E6765742D736861646F7701510140020473656C66C60006 +736861646F777F01000400265B6D6574686F645D746578742D646973706C61792D656E74697479 +2E7365742D736861646F77015204002B5B6D6574686F645D746578742D646973706C61792D656E +746974792E6765742D7365652D7468726F75676801510140020473656C66C6000B7365652D7468 +726F7567687F010004002B5B6D6574686F645D746578742D646973706C61792D656E746974792E +7365742D7365652D7468726F75676801530400325B6D6574686F645D746578742D646973706C61 +792D656E746974792E6765742D64656661756C742D6261636B67726F756E640151014002047365 +6C66C6001264656661756C742D6261636B67726F756E647F01000400325B6D6574686F645D7465 +78742D646973706C61792D656E746974792E7365742D64656661756C742D6261636B67726F756E +6401540140010473656C66C600000D0400295B6D6574686F645D746578742D646973706C61792D +656E746974792E6765742D616C69676E6D656E7401550140020473656C66C60009616C69676E6D +656E740D01000400295B6D6574686F645D746578742D646973706C61792D656E746974792E7365 +742D616C69676E6D656E740156016918016BD70001400106656E746974791900D8000400265B73 +74617469635D696E746572616374696F6E2D656E746974792E66726F6D2D656E74697479015901 +68180140010473656C66DA00001E0400255B6D6574686F645D696E746572616374696F6E2D656E +746974792E6765742D656E74697479015B0140010473656C66DA0000760400245B6D6574686F64 +5D696E746572616374696F6E2D656E746974792E6765742D7769647468015C0140020473656C66 +DA000577696474687601000400245B6D6574686F645D696E746572616374696F6E2D656E746974 +792E7365742D7769647468015D0400255B6D6574686F645D696E746572616374696F6E2D656E74 +6974792E6765742D686569676874015C0140020473656C66DA0006686569676874760100040025 +5B6D6574686F645D696E746572616374696F6E2D656E746974792E7365742D686569676874015E +0140010473656C66DA00007F0400275B6D6574686F645D696E746572616374696F6E2D656E7469 +74792E6765742D726573706F6E7365015F0140020473656C66DA0008726573706F6E73657F0100 +0400275B6D6574686F645D696E746572616374696F6E2D656E746974792E7365742D726573706F +6E73650160016B070140010473656C66DA0000E10004002C5B6D6574686F645D696E7465726163 +74696F6E2D656E746974792E6765742D6C6173742D61747461636B6572016204002F5B6D657468 +6F645D696E746572616374696F6E2D656E746974792E6765742D6C6173742D696E746572616374 +696F6E016203001C70756D706B696E3A706C7567696E2F646973706C617940302E312E30058701 +014202016D3D0E626C6F636B2D61637469766174650C626C6F636B2D6174746163680C626C6F63 +6B2D6368616E67650B626C6F636B2D636C6F736510626C6F636B2D646561637469766174650D62 +6C6F636B2D64657374726F790C626C6F636B2D6465746163680A626C6F636B2D6F70656E0B626C +6F636B2D706C61636506626F756E63650F636F6E7461696E65722D636C6F73650E636F6E746169 +6E65722D6F70656E056472696E6B036561740C656C797472612D676C6964650D656E746974792D +64616D6167650A656E746974792D6469650F656E746974792D6469736D6F756E740F656E746974 +792D696E7465726163740C656E746974792D6D6F756E740C656E746974792D706C6163650D656E +746974792D616374696F6E056571756970076578706C6F646504666C61700C666C7569642D7069 +636B75700B666C7569642D706C6163650A6869742D67726F756E640F696E737472756D656E742D +706C6179146974656D2D696E7465726163742D66696E697368136974656D2D696E746572616374 +2D73746172740C6A756B65626F782D706C6179116A756B65626F782D73746F702D706C6179106C +696768746E696E672D737472696B650F6E6F74652D626C6F636B2D706C61790A7072696D652D66 +7573650F70726F6A656374696C652D6C616E641070726F6A656374696C652D73686F6F741E7363 +756C6B2D73656E736F722D74656E6472696C732D636C69636B696E670573686561720673687269 +656B0673706C6173680473746570047377696D0874656C65706F727407756E65717569700A7265 +736F6E6174652D310A7265736F6E6174652D320A7265736F6E6174652D330A7265736F6E617465 +2D340A7265736F6E6174652D350A7265736F6E6174652D360A7265736F6E6174652D370A726573 +6F6E6174652D380A7265736F6E6174652D390B7265736F6E6174652D31300B7265736F6E617465 +2D31310B7265736F6E6174652D31320B7265736F6E6174652D31330B7265736F6E6174652D3134 +0B7265736F6E6174652D313504000A67616D652D6576656E7403000003002070756D706B696E3A +706C7567696E2F67616D652D6576656E747340302E312E30058801014202016D2E057761746572 +076D756E64616E6505746869636B0761776B776172640C6E696768742D766973696F6E116C6F6E +672D6E696768742D766973696F6E0C696E7669736962696C697479116C6F6E672D696E76697369 +62696C697479076C656170696E670C6C6F6E672D6C656170696E670E7374726F6E672D6C656170 +696E670F666972652D726573697374616E6365146C6F6E672D666972652D726573697374616E63 +650973776966746E6573730E6C6F6E672D73776966746E657373107374726F6E672D7377696674 +6E65737308736C6F776E6573730D6C6F6E672D736C6F776E6573730F7374726F6E672D736C6F77 +6E6573730D747572746C652D6D6173746572126C6F6E672D747572746C652D6D61737465721473 +74726F6E672D747572746C652D6D61737465720F77617465722D627265617468696E67146C6F6E +672D77617465722D627265617468696E67076865616C696E670E7374726F6E672D6865616C696E +67076861726D696E670E7374726F6E672D6861726D696E6706706F69736F6E0B6C6F6E672D706F +69736F6E0D7374726F6E672D706F69736F6E0C726567656E65726174696F6E116C6F6E672D7265 +67656E65726174696F6E137374726F6E672D726567656E65726174696F6E08737472656E677468 +0D6C6F6E672D737472656E6774680F7374726F6E672D737472656E677468087765616B6E657373 +0D6C6F6E672D7765616B6E657373046C75636B0C736C6F772D66616C6C696E67116C6F6E672D73 +6C6F772D66616C6C696E670C77696E642D636861726765640777656176696E67066F6F7A696E67 +08696E66657374656404000B706F74696F6E2D7479706503000003001C70756D706B696E3A706C +7567696E2F706F74696F6E7340302E312E300589010203002307636F6E74657874030007636F6E +7465787403008A0102030022056576656E740300056576656E7403008C0103000F736572766572 +2D696E7374616E6365030063020300210E636F6D6D616E642D73656E64657203000E636F6D6D61 +6E642D73656E64657203008F01020300210D636F6E73756D65642D6172677303000D636F6E7375 +6D65642D6172677303009101020300210D636F6D6D616E642D6572726F7203000D636F6D6D616E +642D6572726F72030093010203002113636F6D6D616E642D73756767657374696F6E7303001363 +6F6D6D616E642D73756767657374696F6E7303009501020300211273756767657374696F6E2D72 +65717565737403001273756767657374696F6E2D7265717565737403009701030006656E746974 +79030041020300130C6368756E6B2D62756666657203000C6368756E6B2D62756666657203009A +01020300131067656E65726174696F6E2D706861736503001067656E65726174696F6E2D706861 +736503009C010203002809706C7567696E2D6964030009706C7567696E2D696403009E01020300 +280B6970632D6D65737361676503000B6970632D6D6573736167650300A001014000010004000B +696E69742D706C7567696E01A20101698B01016A00017301400107636F6E74657874A30100A401 +0400076F6E2D6C6F616401A5010400096F6E2D756E6C6F616401A50101698E0101400308657665 +6E742D69647906736572766572A601056576656E748D01008D0104000C68616E646C652D657665 +6E7401A7010169900101699201016A017A0194010140040A636F6D6D616E642D6964790673656E +646572A80106736572766572A6010461726773A90100AA0104000E68616E646C652D636F6D6D61 +6E6401AB010140040A68616E646C65722D6964790673656E646572A80106736572766572A60107 +72657175657374980100960104001968616E646C652D636F6D6D616E642D73756767657374696F +6E01AC010140020A68616E646C65722D69647906736572766572A601010004000B68616E646C65 +2D7461736B01AD01016A01A10101730140020673656E6465729F01076D657373616765A10100AE +0104001268616E646C652D6970632D6D65737361676501AF010169990101400307676F616C2D69 +647906736572766572A60106656E74697479B001007F04001868616E646C652D61692D676F616C +2D63616E2D737461727401B10104001E68616E646C652D61692D676F616C2D73686F756C642D63 +6F6E74696E756501B10101400307676F616C2D69647906736572766572A60106656E74697479B0 +01010004001468616E646C652D61692D676F616C2D737461727401B20104001368616E646C652D +61692D676F616C2D7469636B01B20104001368616E646C652D61692D676F616C2D73746F7001B2 +0101699B010140030C67656E657261746F722D6964790570686173659D01056368756E6BB30101 +0004001568616E646C652D67656E65726174652D706861736501B401014205017073017206046E +616D65730776657273696F6E7307617574686F7273000B6465736372697074696F6E730C646570 +656E64656E63696573000B7065726D697373696F6E730004000F706C7567696E2D6D6574616461 +7461030001014000000204000C6765742D6D65746164617461010304001D70756D706B696E3A70 +6C7567696E2F6D6574616461746140302E312E3005B50104001B70756D706B696E3A706C756769 +6E2F706C7567696E40302E312E3004000B0C010006706C7567696E03000000440970726F647563 +657273010C70726F6365737365642D6279020D7769742D636F6D706F6E656E7407302E3235392E +300D7769742D62696E6467656E2D6406302E36322E30 +"; + +private enum componentTypeStr = (() { + immutable input = componentTypeBytes; + auto result = new char[input.length*3]; + + foreach (i, b; input) { + result[(i*3)+0] = '\\'; + + ubyte n1 = (b >> 4) & 0xF; + result[(i*3)+1] = n1 < 0xA ? cast(char)('0'+n1) : cast(char)('A'+(n1-0xA)); + + ubyte n2 = b & 0xF; + result[(i*3)+2] = n2 < 0xA ? cast(char)('0'+n2) : cast(char)('A'+(n2-0xA)); + } + + return cast(string)result; +})(); + +pragma(inline, false) +package(wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow {} + + +package(wit) void __wit_bindgen_component_type() { + imported!"ldc.llvmasm".__irEx!( + "", + "", + `!wasm.custom_sections = !{!0} + !0 = !{!"component-type:wit-bindgen:0.62.0:pumpkin:plugin@0.1.0:plugin:", !"`~componentTypeStr~`"}`, + void + ); +} diff --git a/src/wit/pumpkin/plugin/potions/common.d b/src/wit/pumpkin/plugin/potions/common.d new file mode 100644 index 0000000..5ef24ad --- /dev/null +++ b/src/wit/pumpkin/plugin/potions/common.d @@ -0,0 +1,245 @@ +/++ + ++/ +module wit.pumpkin.plugin.potions.common; + + +import wit.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +enum PotionType : ubyte { + /++ + + +/ + water, + + /++ + + +/ + mundane, + + /++ + + +/ + thick, + + /++ + + +/ + awkward, + + /++ + + +/ + nightVision, + + /++ + + +/ + longNightVision, + + /++ + + +/ + invisibility, + + /++ + + +/ + longInvisibility, + + /++ + + +/ + leaping, + + /++ + + +/ + longLeaping, + + /++ + + +/ + strongLeaping, + + /++ + + +/ + fireResistance, + + /++ + + +/ + longFireResistance, + + /++ + + +/ + swiftness, + + /++ + + +/ + longSwiftness, + + /++ + + +/ + strongSwiftness, + + /++ + + +/ + slowness, + + /++ + + +/ + longSlowness, + + /++ + + +/ + strongSlowness, + + /++ + + +/ + turtleMaster, + + /++ + + +/ + longTurtleMaster, + + /++ + + +/ + strongTurtleMaster, + + /++ + + +/ + waterBreathing, + + /++ + + +/ + longWaterBreathing, + + /++ + + +/ + healing, + + /++ + + +/ + strongHealing, + + /++ + + +/ + harming, + + /++ + + +/ + strongHarming, + + /++ + + +/ + poison, + + /++ + + +/ + longPoison, + + /++ + + +/ + strongPoison, + + /++ + + +/ + regeneration, + + /++ + + +/ + longRegeneration, + + /++ + + +/ + strongRegeneration, + + /++ + + +/ + strength, + + /++ + + +/ + longStrength, + + /++ + + +/ + strongStrength, + + /++ + + +/ + weakness, + + /++ + + +/ + longWeakness, + + /++ + + +/ + luck, + + /++ + + +/ + slowFalling, + + /++ + + +/ + longSlowFalling, + + /++ + + +/ + windCharged, + + /++ + + +/ + weaving, + + /++ + + +/ + oozing, + + /++ + + +/ + infested, +} \ No newline at end of file diff --git a/src/wit/pumpkin/plugin/potions/imports.d b/src/wit/pumpkin/plugin/potions/imports.d new file mode 100644 index 0000000..43dc166 --- /dev/null +++ b/src/wit/pumpkin/plugin/potions/imports.d @@ -0,0 +1,12 @@ +/++ + ++/ +module wit.pumpkin.plugin.potions.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.potions.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); diff --git a/src/wit/pumpkin/plugin/recipe/common.d b/src/wit/pumpkin/plugin/recipe/common.d new file mode 100644 index 0000000..1921622 --- /dev/null +++ b/src/wit/pumpkin/plugin/recipe/common.d @@ -0,0 +1,147 @@ +/++ + ++/ +module wit.pumpkin.plugin.recipe.common; + + +import wit.common; + +static import wit.pumpkin.plugin.item_stack.common; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ +Recipe category for the recipe book. ++/ +enum RecipeCategory : ubyte { + /++ + + +/ + building, + + /++ + + +/ + redstone, + + /++ + + +/ + equipment, + + /++ + + +/ + misc, + + /++ + + +/ + food, + + /++ + + +/ + blocks, +} +/++ +Represents an ingredient in a recipe. ++/ +struct Ingredient { + mixin WitVariant!( + WitString, // item + WitString, // tag + WitList!(WitString), // oneOf + ); + +public: + enum Tag : ubyte { + /++ + A specific item (e.g. "minecraft:diamond"). + +/ + item, + + /++ + A tag group of items (e.g., "minecraft:logs"). + +/ + tag, + + /++ + One of multiple specific items. + +/ + oneOf, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + A specific item (e.g. "minecraft:diamond"). + +/ + alias item = _create!(Tag.item); + /// ditto + pragma(inline, true) bool isItem() const => _tag == Tag.item; + ///ditto + alias getItem = _get!(Tag.item); + + /++ + A tag group of items (e.g., "minecraft:logs"). + +/ + alias tag = _create!(Tag.tag); + /// ditto + pragma(inline, true) bool isTag() const => _tag == Tag.tag; + ///ditto + alias getTag = _get!(Tag.tag); + + /++ + One of multiple specific items. + +/ + alias oneOf = _create!(Tag.oneOf); + /// ditto + pragma(inline, true) bool isOneOf() const => _tag == Tag.oneOf; + ///ditto + alias getOneOf = _get!(Tag.oneOf); + + void witFree() @nogc nothrow { + switch (_tag) with (Tag) { + case item: _get!(Tag.item).witFree; break; + case tag: _get!(Tag.tag).witFree; break; + case oneOf: _get!(Tag.oneOf).witFree; break; + default: break; + } + } + + void witDrop() @nogc nothrow { + } + + Ingredient witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.item: return _create!(Tag.item)(this._get!(Tag.item).witClone); break; + case Tag.tag: return _create!(Tag.tag)(this._get!(Tag.tag).witClone); break; + case Tag.oneOf: return _create!(Tag.oneOf)(this._get!(Tag.oneOf).witClone); break; + } + } +} + +/++ +Types of cooking stations. ++/ +enum CookingType : ubyte { + /++ + + +/ + smelting, + + /++ + + +/ + blasting, + + /++ + + +/ + smoking, + + /++ + + +/ + campfire, +} \ No newline at end of file diff --git a/src/wit/pumpkin/plugin/recipe/imports.d b/src/wit/pumpkin/plugin/recipe/imports.d new file mode 100644 index 0000000..9a54ead --- /dev/null +++ b/src/wit/pumpkin/plugin/recipe/imports.d @@ -0,0 +1,466 @@ +/++ + ++/ +module wit.pumpkin.plugin.recipe.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.recipe.common; + +static import wit.pumpkin.plugin.item_stack.imports; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias ItemStack = wit.pumpkin.plugin.item_stack.imports.ItemStack; + +/++ +Represents a shaped crafting recipe. ++/ +struct ShapedRecipe { + /++ + The pattern of the recipe (e.g., ["# #", " s ", "# #"]). + +/ + WitList!(WitString) pattern; + + /++ + Mapping of characters in the pattern to ingredients. + +/ + WitList!(Tuple!(WitString, Ingredient)) key; + + /++ + The resulting item stack. + +/ + ItemStack output; + + /++ + The recipe group (optional). + +/ + Option!(WitString) group; + + /++ + The recipe category in the recipe book. + +/ + Option!(RecipeCategory) category; + + /++ + Whether to show a toast notification when the recipe is unlocked. + +/ + Option!(bool) showNotification; + + void witFree() @nogc nothrow { + pattern.witFree; + key.witFree; + group.witFree; + } + + void witDrop() @nogc nothrow { + output.witDrop; + } + + ShapedRecipe witClone() const @nogc nothrow { + ShapedRecipe clone = void; + clone.pattern = this.pattern.witClone; + clone.key = this.key.witClone; + clone.output = this.output.witClone; + clone.group = this.group.witClone; + clone.category = this.category.witClone; + clone.showNotification = this.showNotification.witClone; + return clone; + } +} + +/++ +Represents a shapeless crafting recipe. ++/ +struct ShapelessRecipe { + /++ + The list of ingredients required. + +/ + WitList!(Ingredient) ingredients; + + /++ + The resulting item stack. + +/ + ItemStack output; + + /++ + The recipe group (optional). + +/ + Option!(WitString) group; + + /++ + The recipe category in the recipe book. + +/ + Option!(RecipeCategory) category; + + void witFree() @nogc nothrow { + ingredients.witFree; + group.witFree; + } + + void witDrop() @nogc nothrow { + output.witDrop; + } + + ShapelessRecipe witClone() const @nogc nothrow { + ShapelessRecipe clone = void; + clone.ingredients = this.ingredients.witClone; + clone.output = this.output.witClone; + clone.group = this.group.witClone; + clone.category = this.category.witClone; + return clone; + } +} + +/++ +Represents a cooking recipe (Smelting, Blasting, Smoking, Campfire). ++/ +struct CookingRecipe { + /++ + The ingredient to cook. + +/ + Ingredient ingredient; + + /++ + The resulting item stack. + +/ + ItemStack output; + + /++ + Experience points awarded. + +/ + float experience; + + /++ + Cooking time in ticks. + +/ + uint cookingTime; + + /++ + The recipe group (optional). + +/ + Option!(WitString) group; + + /++ + The recipe category in the recipe book. + +/ + Option!(RecipeCategory) category; + + void witFree() @nogc nothrow { + ingredient.witFree; + group.witFree; + } + + void witDrop() @nogc nothrow { + output.witDrop; + } + + CookingRecipe witClone() const @nogc nothrow { + CookingRecipe clone = void; + clone.ingredient = this.ingredient.witClone; + clone.output = this.output.witClone; + clone.experience = this.experience.witClone; + clone.cookingTime = this.cookingTime.witClone; + clone.group = this.group.witClone; + clone.category = this.category.witClone; + return clone; + } +} + +/++ +Common interface for registering recipes. ++/ +struct RecipeManager { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/recipe@0.1.0", "[resource-drop]recipe-manager") + pragma(mangle, "__wit_import_pumpkin:plugin__recipe@0.1.0__:resource_drop:recipe_manager") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + Registers a shaped crafting recipe. + +/ + void registerShaped(in WitString id, in ShapedRecipe recipe) @trusted nothrow { + wit.common.DeallocateBuffer deallocate; + auto _listSrc1 = recipe.pattern; + auto _list1 = _listSrc1.length ? wit.common.malloc(_listSrc1.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc1.length || _list1); + if (_listSrc1.length) deallocate ~= _list1; + foreach (_elem0_idx, ref _elem0; _listSrc1) { + auto _base0 = _list1 + _elem0_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base0 + size_t.sizeof) = cast(size_t)(_elem0.length); + *cast(void**)(_base0 + 0) = cast(void*)(cast(void*)(_elem0.ptr)); + + } + auto _listSrc12 = recipe.key; + auto _list12 = _listSrc12.length ? wit.common.malloc(_listSrc12.length * ((5*size_t.sizeof))) : null; + assert(!_listSrc12.length || _list12); + if (_listSrc12.length) deallocate ~= _list12; + foreach (_elem2_idx, ref _elem2; _listSrc12) { + auto _base2 = _list12 + _elem2_idx * ((5*size_t.sizeof)); + *cast(size_t*)(_base2 + size_t.sizeof) = cast(size_t)(_elem2[0].length); + *cast(void**)(_base2 + 0) = cast(void*)(cast(void*)(_elem2[0].ptr)); + alias _Tag11 = Ingredient.Tag; + final switch (_elem2[1].tag) { + case _Tag11.item: { + const ref WitString _payload4 = _elem2[1].getItem(); + *cast(ubyte*)(_base2 + (2*size_t.sizeof)) = cast(ubyte)(0); + *cast(size_t*)(_base2 + (4*size_t.sizeof)) = cast(size_t)(_payload4.length); + *cast(void**)(_base2 + (3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload4.ptr)); + break; + } + case _Tag11.tag: { + const ref WitString _payload6 = _elem2[1].getTag(); + *cast(ubyte*)(_base2 + (2*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_base2 + (4*size_t.sizeof)) = cast(size_t)(_payload6.length); + *cast(void**)(_base2 + (3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload6.ptr)); + break; + } + case _Tag11.oneOf: { + const ref WitList!(WitString) _payload8 = _elem2[1].getOneOf(); + *cast(ubyte*)(_base2 + (2*size_t.sizeof)) = cast(ubyte)(2); + auto _listSrc10 = _payload8; + auto _list10 = _listSrc10.length ? wit.common.malloc(_listSrc10.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc10.length || _list10); + if (_listSrc10.length) deallocate ~= _list10; + foreach (_elem9_idx, ref _elem9; _listSrc10) { + auto _base9 = _list10 + _elem9_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base9 + size_t.sizeof) = cast(size_t)(_elem9.length); + *cast(void**)(_base9 + 0) = cast(void*)(cast(void*)(_elem9.ptr)); + + } + *cast(size_t*)(_base2 + (4*size_t.sizeof)) = cast(size_t)(_payload8.length); + *cast(void**)(_base2 + (3*size_t.sizeof)) = cast(void*)(_list10); + break; + } + } + + } + uint _option17 = void; + void* _option18 = void; + size_t _option19 = void; + if (recipe.group.isSome) { + ref _payload16 = recipe.group.unwrap(); + _option17 = 1; + _option18 = cast(void*)(_payload16.ptr); + _option19 = _payload16.length; + } else { + _option17 = 0; + _option18 = null; + _option19 = 0; + } + uint _option24 = void; + uint _option25 = void; + if (recipe.category.isSome) { + ref _payload23 = recipe.category.unwrap(); + _option24 = 1; + _option25 = cast(uint)(_payload23); + } else { + _option24 = 0; + _option25 = 0; + } + uint _option30 = void; + uint _option31 = void; + if (recipe.showNotification.isSome) { + ref _payload29 = recipe.showNotification.unwrap(); + _option30 = 1; + _option31 = cast(uint)(_payload29); + } else { + _option30 = 0; + _option31 = 0; + } + __import_registerShaped(this.__handle, cast(void*)(id.ptr), id.length, _list1, recipe.pattern.length, _list12, recipe.key.length, recipe.output.__handle, _option17, _option18, _option19, _option24, _option25, _option30, _option31); + deallocate.purge(); + } + /// ditto + @wasmImport!("pumpkin:plugin/recipe@0.1.0", "[method]recipe-manager.register-shaped") + pragma(mangle, "__wit_import_pumpkin:plugin__recipe@0.1.0__:method:recipe_manager.register_shaped") + static private extern(C) void __import_registerShaped(uint, void*, size_t, void*, size_t, void*, size_t, uint, uint, void*, size_t, uint, uint, uint, uint) nothrow; + + /++ + Registers a shapeless crafting recipe. + +/ + void registerShapeless(in WitString id, in ShapelessRecipe recipe) @trusted nothrow { + wit.common.DeallocateBuffer deallocate; + auto _listSrc10 = recipe.ingredients; + auto _list10 = _listSrc10.length ? wit.common.malloc(_listSrc10.length * ((3*size_t.sizeof))) : null; + assert(!_listSrc10.length || _list10); + if (_listSrc10.length) deallocate ~= _list10; + foreach (_elem0_idx, ref _elem0; _listSrc10) { + auto _base0 = _list10 + _elem0_idx * ((3*size_t.sizeof)); + alias _Tag9 = Ingredient.Tag; + final switch (_elem0.tag) { + case _Tag9.item: { + const ref WitString _payload2 = _elem0.getItem(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(0); + *cast(size_t*)(_base0 + (2*size_t.sizeof)) = cast(size_t)(_payload2.length); + *cast(void**)(_base0 + size_t.sizeof) = cast(void*)(cast(void*)(_payload2.ptr)); + break; + } + case _Tag9.tag: { + const ref WitString _payload4 = _elem0.getTag(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(1); + *cast(size_t*)(_base0 + (2*size_t.sizeof)) = cast(size_t)(_payload4.length); + *cast(void**)(_base0 + size_t.sizeof) = cast(void*)(cast(void*)(_payload4.ptr)); + break; + } + case _Tag9.oneOf: { + const ref WitList!(WitString) _payload6 = _elem0.getOneOf(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(2); + auto _listSrc8 = _payload6; + auto _list8 = _listSrc8.length ? wit.common.malloc(_listSrc8.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc8.length || _list8); + if (_listSrc8.length) deallocate ~= _list8; + foreach (_elem7_idx, ref _elem7; _listSrc8) { + auto _base7 = _list8 + _elem7_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base7 + size_t.sizeof) = cast(size_t)(_elem7.length); + *cast(void**)(_base7 + 0) = cast(void*)(cast(void*)(_elem7.ptr)); + + } + *cast(size_t*)(_base0 + (2*size_t.sizeof)) = cast(size_t)(_payload6.length); + *cast(void**)(_base0 + size_t.sizeof) = cast(void*)(_list8); + break; + } + } + + } + uint _option15 = void; + void* _option16 = void; + size_t _option17 = void; + if (recipe.group.isSome) { + ref _payload14 = recipe.group.unwrap(); + _option15 = 1; + _option16 = cast(void*)(_payload14.ptr); + _option17 = _payload14.length; + } else { + _option15 = 0; + _option16 = null; + _option17 = 0; + } + uint _option22 = void; + uint _option23 = void; + if (recipe.category.isSome) { + ref _payload21 = recipe.category.unwrap(); + _option22 = 1; + _option23 = cast(uint)(_payload21); + } else { + _option22 = 0; + _option23 = 0; + } + __import_registerShapeless(this.__handle, cast(void*)(id.ptr), id.length, _list10, recipe.ingredients.length, recipe.output.__handle, _option15, _option16, _option17, _option22, _option23); + deallocate.purge(); + } + /// ditto + @wasmImport!("pumpkin:plugin/recipe@0.1.0", "[method]recipe-manager.register-shapeless") + pragma(mangle, "__wit_import_pumpkin:plugin__recipe@0.1.0__:method:recipe_manager.register_shapeless") + static private extern(C) void __import_registerShapeless(uint, void*, size_t, void*, size_t, uint, uint, void*, size_t, uint, uint) nothrow; + + /++ + Registers a cooking recipe. + +/ + void registerCooking(in WitString id, CookingType stationType, in CookingRecipe recipe) @trusted nothrow { + wit.common.DeallocateBuffer deallocate; + uint _variantPart8 = void; + void* _variantPart9 = void; + size_t _variantPart10 = void; + alias _Tag11 = Ingredient.Tag; + final switch (recipe.ingredient.tag) { + case _Tag11.item: { + const ref WitString _payload1 = recipe.ingredient.getItem(); + _variantPart8 = 0; + _variantPart9 = cast(void*)(_payload1.ptr); + _variantPart10 = _payload1.length; + break; + } + case _Tag11.tag: { + const ref WitString _payload3 = recipe.ingredient.getTag(); + _variantPart8 = 1; + _variantPart9 = cast(void*)(_payload3.ptr); + _variantPart10 = _payload3.length; + break; + } + case _Tag11.oneOf: { + const ref WitList!(WitString) _payload5 = recipe.ingredient.getOneOf(); + auto _listSrc7 = _payload5; + auto _list7 = _listSrc7.length ? wit.common.malloc(_listSrc7.length * ((2*size_t.sizeof))) : null; + assert(!_listSrc7.length || _list7); + if (_listSrc7.length) deallocate ~= _list7; + foreach (_elem6_idx, ref _elem6; _listSrc7) { + auto _base6 = _list7 + _elem6_idx * ((2*size_t.sizeof)); + *cast(size_t*)(_base6 + size_t.sizeof) = cast(size_t)(_elem6.length); + *cast(void**)(_base6 + 0) = cast(void*)(cast(void*)(_elem6.ptr)); + + } + _variantPart8 = 2; + _variantPart9 = _list7; + _variantPart10 = _payload5.length; + break; + } + } + uint _option16 = void; + void* _option17 = void; + size_t _option18 = void; + if (recipe.group.isSome) { + ref _payload15 = recipe.group.unwrap(); + _option16 = 1; + _option17 = cast(void*)(_payload15.ptr); + _option18 = _payload15.length; + } else { + _option16 = 0; + _option17 = null; + _option18 = 0; + } + uint _option23 = void; + uint _option24 = void; + if (recipe.category.isSome) { + ref _payload22 = recipe.category.unwrap(); + _option23 = 1; + _option24 = cast(uint)(_payload22); + } else { + _option23 = 0; + _option24 = 0; + } + __import_registerCooking(this.__handle, cast(void*)(id.ptr), id.length, cast(uint)(stationType), _variantPart8, _variantPart9, _variantPart10, recipe.output.__handle, recipe.experience, recipe.cookingTime, _option16, _option17, _option18, _option23, _option24); + deallocate.purge(); + } + /// ditto + @wasmImport!("pumpkin:plugin/recipe@0.1.0", "[method]recipe-manager.register-cooking") + pragma(mangle, "__wit_import_pumpkin:plugin__recipe@0.1.0__:method:recipe_manager.register_cooking") + static private extern(C) void __import_registerCooking(uint, void*, size_t, uint, uint, void*, size_t, uint, float, uint, uint, void*, size_t, uint, uint) nothrow; + } +} diff --git a/src/wit/pumpkin/plugin/scheduler/common.d b/src/wit/pumpkin/plugin/scheduler/common.d new file mode 100644 index 0000000..2e7544a --- /dev/null +++ b/src/wit/pumpkin/plugin/scheduler/common.d @@ -0,0 +1,10 @@ +/++ +Provides functionality to schedule tasks to be executed later on the server. ++/ +module wit.pumpkin.plugin.scheduler.common; + + +import wit.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); diff --git a/src/wit/pumpkin/plugin/scheduler/imports.d b/src/wit/pumpkin/plugin/scheduler/imports.d new file mode 100644 index 0000000..fc48a91 --- /dev/null +++ b/src/wit/pumpkin/plugin/scheduler/imports.d @@ -0,0 +1,60 @@ +/++ +Provides functionality to schedule tasks to be executed later on the server. ++/ +module wit.pumpkin.plugin.scheduler.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.scheduler.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ +Schedules a task to be executed once after the specified number of ticks. + +* `handler-id`: The unique ID of the handler to call when the task executes. +* `delay-ticks`: The number of game ticks to wait before execution (20 ticks = 1 second). + +Returns a unique task ID that can be used to cancel the task. ++/ +uint scheduleDelayedTask(uint handlerId, ulong delayTicks) @trusted nothrow { + auto _ret = __import_scheduleDelayedTask(handlerId, delayTicks); + return _ret; +} +/// ditto +@wasmImport!("pumpkin:plugin/scheduler@0.1.0", "schedule-delayed-task") +pragma(mangle, "__wit_import_pumpkin:plugin__scheduler@0.1.0__schedule_delayed_task") +private extern(C) uint __import_scheduleDelayedTask(uint, ulong) nothrow; + +/++ +Schedules a task to be executed repeatedly. + +* `handler-id`: The unique ID of the handler to call when the task executes. +* `delay-ticks`: The number of game ticks to wait before the first execution. +* `period-ticks`: The number of game ticks between subsequent executions. + +Returns a unique task ID that can be used to cancel the task. ++/ +uint scheduleRepeatingTask(uint handlerId, ulong delayTicks, ulong periodTicks) @trusted nothrow { + auto _ret = __import_scheduleRepeatingTask(handlerId, delayTicks, periodTicks); + return _ret; +} +/// ditto +@wasmImport!("pumpkin:plugin/scheduler@0.1.0", "schedule-repeating-task") +pragma(mangle, "__wit_import_pumpkin:plugin__scheduler@0.1.0__schedule_repeating_task") +private extern(C) uint __import_scheduleRepeatingTask(uint, ulong, ulong) nothrow; + +/++ +Cancels a scheduled task if it hasn't finished yet. + +* `task-id`: The ID of the task to cancel. ++/ +void cancelTask(uint taskId) @trusted nothrow { + __import_cancelTask(taskId); +} +/// ditto +@wasmImport!("pumpkin:plugin/scheduler@0.1.0", "cancel-task") +pragma(mangle, "__wit_import_pumpkin:plugin__scheduler@0.1.0__cancel_task") +private extern(C) void __import_cancelTask(uint) nothrow; diff --git a/src/wit/pumpkin/plugin/scoreboard/common.d b/src/wit/pumpkin/plugin/scoreboard/common.d new file mode 100644 index 0000000..c6703e3 --- /dev/null +++ b/src/wit/pumpkin/plugin/scoreboard/common.d @@ -0,0 +1,212 @@ +/++ + ++/ +module wit.pumpkin.plugin.scoreboard.common; + + +import wit.common; + +static import wit.pumpkin.plugin.common.common; +static import wit.pumpkin.plugin.text.common; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias NamedColor = wit.pumpkin.plugin.common.common.NamedColor; + +/++ + ++/ +enum RenderType : ubyte { + /++ + + +/ + integer, + + /++ + + +/ + hearts, +} +/++ + ++/ +enum DisplaySlot : ubyte { + /++ + + +/ + playerList, + + /++ + + +/ + sidebar, + + /++ + + +/ + belowName, + + /++ + + +/ + sidebarTeamBlack, + + /++ + + +/ + sidebarTeamDarkBlue, + + /++ + + +/ + sidebarTeamDarkGreen, + + /++ + + +/ + sidebarTeamDarkAqua, + + /++ + + +/ + sidebarTeamDarkRed, + + /++ + + +/ + sidebarTeamDarkPurple, + + /++ + + +/ + sidebarTeamGold, + + /++ + + +/ + sidebarTeamGray, + + /++ + + +/ + sidebarTeamDarkGray, + + /++ + + +/ + sidebarTeamBlue, + + /++ + + +/ + sidebarTeamGreen, + + /++ + + +/ + sidebarTeamAqua, + + /++ + + +/ + sidebarTeamRed, + + /++ + + +/ + sidebarTeamLightPurple, + + /++ + + +/ + sidebarTeamYellow, + + /++ + + +/ + sidebarTeamWhite, +} +/++ + ++/ +enum NametagVisibility : ubyte { + /++ + + +/ + always, + + /++ + + +/ + never, + + /++ + + +/ + hideForOtherTeams, + + /++ + + +/ + hideForOwnTeam, +} +/++ + ++/ +enum CollisionRule : ubyte { + /++ + + +/ + always, + + /++ + + +/ + never, + + /++ + + +/ + pushOtherTeams, + + /++ + + +/ + pushOwnTeam, +} +/++ + ++/ +enum BedrockSortOrder : ubyte { + /++ + + +/ + ascending, + + /++ + + +/ + descending, +} +/++ + ++/ +enum BedrockDisplaySlot : ubyte { + /++ + + +/ + playerList, + + /++ + + +/ + sidebar, + + /++ + + +/ + belowName, +} \ No newline at end of file diff --git a/src/wit/pumpkin/plugin/scoreboard/imports.d b/src/wit/pumpkin/plugin/scoreboard/imports.d new file mode 100644 index 0000000..08a30a1 --- /dev/null +++ b/src/wit/pumpkin/plugin/scoreboard/imports.d @@ -0,0 +1,696 @@ +/++ + ++/ +module wit.pumpkin.plugin.scoreboard.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.scoreboard.common; + +static import wit.pumpkin.plugin.common.imports; +static import wit.pumpkin.plugin.text.imports; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias TextComponent = wit.pumpkin.plugin.text.imports.TextComponent; + +/++ + ++/ +struct NumberFormat { + mixin WitVariant!( + void, // blank + TextComponent, // fixed + ); + +public: + enum Tag : ubyte { + /++ + + +/ + blank, + + /++ + + +/ + fixed, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias blank = _create!(Tag.blank); + /// ditto + pragma(inline, true) bool isBlank() const => _tag == Tag.blank; + + /++ + + +/ + alias fixed = _create!(Tag.fixed); + /// ditto + pragma(inline, true) bool isFixed() const => _tag == Tag.fixed; + ///ditto + alias getFixed = _get!(Tag.fixed); + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + switch (_tag) with (Tag) { + case fixed: _get!(Tag.fixed).witDrop; break; + default: break; + } + } + + NumberFormat witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.blank: return _create!(Tag.blank); break; + case Tag.fixed: return _create!(Tag.fixed)(this._get!(Tag.fixed).witClone); break; + } + } +} + +/++ + ++/ +struct TeamSettings { + /++ + + +/ + TextComponent displayName; + + /++ + + +/ + bool friendlyFire; + + /++ + + +/ + bool seeFriendlyInvisibles; + + /++ + + +/ + NametagVisibility nametagVisibility; + + /++ + + +/ + CollisionRule collisionRule; + + /++ + + +/ + NamedColor color; + + /++ + + +/ + TextComponent prefix; + + /++ + + +/ + TextComponent suffix; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + displayName.witDrop; + prefix.witDrop; + suffix.witDrop; + } + + TeamSettings witClone() const @nogc nothrow { + TeamSettings clone = void; + clone.displayName = this.displayName.witClone; + clone.friendlyFire = this.friendlyFire.witClone; + clone.seeFriendlyInvisibles = this.seeFriendlyInvisibles.witClone; + clone.nametagVisibility = this.nametagVisibility.witClone; + clone.collisionRule = this.collisionRule.witClone; + clone.color = this.color.witClone; + clone.prefix = this.prefix.witClone; + clone.suffix = this.suffix.witClone; + return clone; + } +} + +/++ + ++/ +struct Scoreboard { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[resource-drop]scoreboard") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:resource_drop:scoreboard") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + void addObjective(in WitString name, TextComponent displayName, RenderType renderType, in Option!(NumberFormat) numberFormat) @trusted nothrow { + uint _option11 = void; + uint _option12 = void; + uint _option13 = void; + if (numberFormat.isSome) { + ref _payload3 = numberFormat.unwrap(); + uint _variantPart8 = void; + uint _variantPart9 = void; + alias _Tag10 = NumberFormat.Tag; + final switch (_payload3.tag) { + case _Tag10.blank: { + _variantPart8 = 0; + _variantPart9 = 0; + break; + } + case _Tag10.fixed: { + const ref TextComponent _payload7 = _payload3.getFixed(); + _variantPart8 = 1; + _variantPart9 = _payload7.__handle; + break; + } + } + _option11 = 1; + _option12 = _variantPart8; + _option13 = _variantPart9; + } else { + _option11 = 0; + _option12 = 0; + _option13 = 0; + } + __import_addObjective(this.__handle, cast(void*)(name.ptr), name.length, displayName.__handle, cast(uint)(renderType), _option11, _option12, _option13); + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]scoreboard.add-objective") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:scoreboard.add_objective") + static private extern(C) void __import_addObjective(uint, void*, size_t, uint, uint, uint, uint, uint) nothrow; + + /++ + + +/ + void updateObjective(in WitString name, TextComponent displayName, RenderType renderType, in Option!(NumberFormat) numberFormat) @trusted nothrow { + uint _option11 = void; + uint _option12 = void; + uint _option13 = void; + if (numberFormat.isSome) { + ref _payload3 = numberFormat.unwrap(); + uint _variantPart8 = void; + uint _variantPart9 = void; + alias _Tag10 = NumberFormat.Tag; + final switch (_payload3.tag) { + case _Tag10.blank: { + _variantPart8 = 0; + _variantPart9 = 0; + break; + } + case _Tag10.fixed: { + const ref TextComponent _payload7 = _payload3.getFixed(); + _variantPart8 = 1; + _variantPart9 = _payload7.__handle; + break; + } + } + _option11 = 1; + _option12 = _variantPart8; + _option13 = _variantPart9; + } else { + _option11 = 0; + _option12 = 0; + _option13 = 0; + } + __import_updateObjective(this.__handle, cast(void*)(name.ptr), name.length, displayName.__handle, cast(uint)(renderType), _option11, _option12, _option13); + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]scoreboard.update-objective") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:scoreboard.update_objective") + static private extern(C) void __import_updateObjective(uint, void*, size_t, uint, uint, uint, uint, uint) nothrow; + + /++ + + +/ + void removeObjective(in WitString name) @trusted nothrow { + __import_removeObjective(this.__handle, cast(void*)(name.ptr), name.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]scoreboard.remove-objective") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:scoreboard.remove_objective") + static private extern(C) void __import_removeObjective(uint, void*, size_t) nothrow; + + /++ + + +/ + void setDisplaySlot(DisplaySlot slot, in WitString objectiveName) @trusted nothrow { + __import_setDisplaySlot(this.__handle, cast(uint)(slot), cast(void*)(objectiveName.ptr), objectiveName.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]scoreboard.set-display-slot") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:scoreboard.set_display_slot") + static private extern(C) void __import_setDisplaySlot(uint, uint, void*, size_t) nothrow; + + /++ + + +/ + void clearDisplaySlot(DisplaySlot slot) @trusted nothrow { + __import_clearDisplaySlot(this.__handle, cast(uint)(slot)); + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]scoreboard.clear-display-slot") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:scoreboard.clear_display_slot") + static private extern(C) void __import_clearDisplaySlot(uint, uint) nothrow; + + /++ + + +/ + void updateScore(in WitString entityName, in WitString objectiveName, int value, in Option!(NumberFormat) numberFormat) @trusted nothrow { + uint _option11 = void; + uint _option12 = void; + uint _option13 = void; + if (numberFormat.isSome) { + ref _payload3 = numberFormat.unwrap(); + uint _variantPart8 = void; + uint _variantPart9 = void; + alias _Tag10 = NumberFormat.Tag; + final switch (_payload3.tag) { + case _Tag10.blank: { + _variantPart8 = 0; + _variantPart9 = 0; + break; + } + case _Tag10.fixed: { + const ref TextComponent _payload7 = _payload3.getFixed(); + _variantPart8 = 1; + _variantPart9 = _payload7.__handle; + break; + } + } + _option11 = 1; + _option12 = _variantPart8; + _option13 = _variantPart9; + } else { + _option11 = 0; + _option12 = 0; + _option13 = 0; + } + __import_updateScore(this.__handle, cast(void*)(entityName.ptr), entityName.length, cast(void*)(objectiveName.ptr), objectiveName.length, cast(uint)(value), _option11, _option12, _option13); + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]scoreboard.update-score") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:scoreboard.update_score") + static private extern(C) void __import_updateScore(uint, void*, size_t, void*, size_t, uint, uint, uint, uint) nothrow; + + /++ + + +/ + int addScore(in WitString entityName, in WitString objectiveName, int delta) @trusted nothrow { + auto _ret = __import_addScore(this.__handle, cast(void*)(entityName.ptr), entityName.length, cast(void*)(objectiveName.ptr), objectiveName.length, cast(uint)(delta)); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]scoreboard.add-score") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:scoreboard.add_score") + static private extern(C) uint __import_addScore(uint, void*, size_t, void*, size_t, uint) nothrow; + + /++ + + +/ + void removeScore(in WitString entityName, in WitString objectiveName) @trusted nothrow { + __import_removeScore(this.__handle, cast(void*)(entityName.ptr), entityName.length, cast(void*)(objectiveName.ptr), objectiveName.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]scoreboard.remove-score") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:scoreboard.remove_score") + static private extern(C) void __import_removeScore(uint, void*, size_t, void*, size_t) nothrow; + + /++ + + +/ + void resetEntityScores(in WitString entityName) @trusted nothrow { + __import_resetEntityScores(this.__handle, cast(void*)(entityName.ptr), entityName.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]scoreboard.reset-entity-scores") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:scoreboard.reset_entity_scores") + static private extern(C) void __import_resetEntityScores(uint, void*, size_t) nothrow; + + /++ + + +/ + void createTeam(in WitString name, in TeamSettings settings) @trusted nothrow { + __import_createTeam(this.__handle, cast(void*)(name.ptr), name.length, settings.displayName.__handle, cast(uint)(settings.friendlyFire), cast(uint)(settings.seeFriendlyInvisibles), cast(uint)(settings.nametagVisibility), cast(uint)(settings.collisionRule), cast(uint)(settings.color), settings.prefix.__handle, settings.suffix.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]scoreboard.create-team") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:scoreboard.create_team") + static private extern(C) void __import_createTeam(uint, void*, size_t, uint, uint, uint, uint, uint, uint, uint, uint) nothrow; + + /++ + + +/ + void removeTeam(in WitString name) @trusted nothrow { + __import_removeTeam(this.__handle, cast(void*)(name.ptr), name.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]scoreboard.remove-team") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:scoreboard.remove_team") + static private extern(C) void __import_removeTeam(uint, void*, size_t) nothrow; + + /++ + + +/ + void updateTeam(in WitString name, in TeamSettings settings) @trusted nothrow { + __import_updateTeam(this.__handle, cast(void*)(name.ptr), name.length, settings.displayName.__handle, cast(uint)(settings.friendlyFire), cast(uint)(settings.seeFriendlyInvisibles), cast(uint)(settings.nametagVisibility), cast(uint)(settings.collisionRule), cast(uint)(settings.color), settings.prefix.__handle, settings.suffix.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]scoreboard.update-team") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:scoreboard.update_team") + static private extern(C) void __import_updateTeam(uint, void*, size_t, uint, uint, uint, uint, uint, uint, uint, uint) nothrow; + + /++ + + +/ + void addPlayerToTeam(in WitString teamName, in WitString playerName) @trusted nothrow { + __import_addPlayerToTeam(this.__handle, cast(void*)(teamName.ptr), teamName.length, cast(void*)(playerName.ptr), playerName.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]scoreboard.add-player-to-team") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:scoreboard.add_player_to_team") + static private extern(C) void __import_addPlayerToTeam(uint, void*, size_t, void*, size_t) nothrow; + + /++ + + +/ + void removePlayerFromTeam(in WitString teamName, in WitString playerName) @trusted nothrow { + __import_removePlayerFromTeam(this.__handle, cast(void*)(teamName.ptr), teamName.length, cast(void*)(playerName.ptr), playerName.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]scoreboard.remove-player-from-team") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:scoreboard.remove_player_from_team") + static private extern(C) void __import_removePlayerFromTeam(uint, void*, size_t, void*, size_t) nothrow; + + /++ + + +/ + void clearTeamPlayers(in WitString teamName) @trusted nothrow { + __import_clearTeamPlayers(this.__handle, cast(void*)(teamName.ptr), teamName.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]scoreboard.clear-team-players") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:scoreboard.clear_team_players") + static private extern(C) void __import_clearTeamPlayers(uint, void*, size_t) nothrow; + + /++ + + +/ + WitList!(WitString) getTeams() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getTeams(this.__handle, _retArea.ptr); + auto _listSrcPtr3 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen3 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list3 = _listLen3 ? wit.common.mallocSlice!(WitString)(_listLen3) : []; + assert(!_listLen3 || _list3.ptr); + foreach (_elem0_idx, ref _elem0; _list3) { + const auto _base0 = _listSrcPtr3 + _elem0_idx * (2*size_t.sizeof); + auto _len1 = *(cast(size_t*)(_base0 + size_t.sizeof)); + auto _ptr1 = _len1 ? cast(char*)(*(cast(void**)(_base0 + 0))) : null; + auto _list2 = WitString(_ptr1[0.._len1]); + _elem0 = _list2; + } + if (_listLen3) wit.common.free(_listSrcPtr3); + auto _witList4 = WitList!(WitString)(_list3); + auto _flush5 = _witList4; + return _flush5; + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]scoreboard.get-teams") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:scoreboard.get_teams") + static private extern(C) void __import_getTeams(uint, void*) nothrow; + + /++ + + +/ + Option!(TeamSettings) getTeam(in WitString name) @trusted nothrow { + align(4) void[24] _retArea = void; + __import_getTeam(this.__handle, cast(void*)(name.ptr), name.length, _retArea.ptr); + Option!(TeamSettings) _option6 = void; + bool _isSome6 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome6) { + auto _handle2 = TextComponent(*(cast(uint*)(_retArea.ptr + 4))); + auto _handle3 = TextComponent(*(cast(uint*)(_retArea.ptr + 16))); + auto _handle4 = TextComponent(*(cast(uint*)(_retArea.ptr + 20))); + TeamSettings _record5 = { + displayName: _handle2, + friendlyFire: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 8)))) != 0, + seeFriendlyInvisibles: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 9)))) != 0, + nametagVisibility: cast(NametagVisibility)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 10)))), + collisionRule: cast(CollisionRule)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 11)))), + color: cast(wit.pumpkin.plugin.common.imports.NamedColor)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 12)))), + prefix: _handle3, + suffix: _handle4, + }; + + _option6 = Option!(TeamSettings).makeSome(_record5); + } else { + _option6 = Option!(TeamSettings).makeNone; + } + auto _flush7 = _option6; + return _flush7; + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]scoreboard.get-team") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:scoreboard.get_team") + static private extern(C) void __import_getTeam(uint, void*, size_t, void*) nothrow; + + /++ + + +/ + WitList!(WitString) getTeamPlayers(in WitString teamName) @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getTeamPlayers(this.__handle, cast(void*)(teamName.ptr), teamName.length, _retArea.ptr); + auto _listSrcPtr3 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen3 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list3 = _listLen3 ? wit.common.mallocSlice!(WitString)(_listLen3) : []; + assert(!_listLen3 || _list3.ptr); + foreach (_elem0_idx, ref _elem0; _list3) { + const auto _base0 = _listSrcPtr3 + _elem0_idx * (2*size_t.sizeof); + auto _len1 = *(cast(size_t*)(_base0 + size_t.sizeof)); + auto _ptr1 = _len1 ? cast(char*)(*(cast(void**)(_base0 + 0))) : null; + auto _list2 = WitString(_ptr1[0.._len1]); + _elem0 = _list2; + } + if (_listLen3) wit.common.free(_listSrcPtr3); + auto _witList4 = WitList!(WitString)(_list3); + auto _flush5 = _witList4; + return _flush5; + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]scoreboard.get-team-players") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:scoreboard.get_team_players") + static private extern(C) void __import_getTeamPlayers(uint, void*, size_t, void*) nothrow; + + /++ + + +/ + Option!(WitString) getPlayerTeam(in WitString playerName) @trusted nothrow { + align(size_t.sizeof) void[(3*size_t.sizeof)] _retArea = void; + __import_getPlayerTeam(this.__handle, cast(void*)(playerName.ptr), playerName.length, _retArea.ptr); + Option!(WitString) _option4 = void; + bool _isSome4 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome4) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + + _option4 = Option!(WitString).makeSome(_list3); + } else { + _option4 = Option!(WitString).makeNone; + } + auto _flush5 = _option4; + return _flush5; + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]scoreboard.get-player-team") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:scoreboard.get_player_team") + static private extern(C) void __import_getPlayerTeam(uint, void*, size_t, void*) nothrow; + } +} + +/++ + ++/ +struct BedrockScoreboard { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[resource-drop]bedrock-scoreboard") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:resource_drop:bedrock_scoreboard") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + void addObjective(in WitString name, in WitString displayName, BedrockSortOrder sortOrder) @trusted nothrow { + __import_addObjective(this.__handle, cast(void*)(name.ptr), name.length, cast(void*)(displayName.ptr), displayName.length, cast(uint)(sortOrder)); + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]bedrock-scoreboard.add-objective") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:bedrock_scoreboard.add_objective") + static private extern(C) void __import_addObjective(uint, void*, size_t, void*, size_t, uint) nothrow; + + /++ + + +/ + void updateObjective(in WitString name, in WitString displayName, BedrockSortOrder sortOrder) @trusted nothrow { + __import_updateObjective(this.__handle, cast(void*)(name.ptr), name.length, cast(void*)(displayName.ptr), displayName.length, cast(uint)(sortOrder)); + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]bedrock-scoreboard.update-objective") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:bedrock_scoreboard.update_objective") + static private extern(C) void __import_updateObjective(uint, void*, size_t, void*, size_t, uint) nothrow; + + /++ + + +/ + void removeObjective(in WitString name) @trusted nothrow { + __import_removeObjective(this.__handle, cast(void*)(name.ptr), name.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]bedrock-scoreboard.remove-objective") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:bedrock_scoreboard.remove_objective") + static private extern(C) void __import_removeObjective(uint, void*, size_t) nothrow; + + /++ + + +/ + void setDisplaySlot(BedrockDisplaySlot slot, in WitString objectiveName) @trusted nothrow { + __import_setDisplaySlot(this.__handle, cast(uint)(slot), cast(void*)(objectiveName.ptr), objectiveName.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]bedrock-scoreboard.set-display-slot") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:bedrock_scoreboard.set_display_slot") + static private extern(C) void __import_setDisplaySlot(uint, uint, void*, size_t) nothrow; + + /++ + + +/ + void clearDisplaySlot(BedrockDisplaySlot slot) @trusted nothrow { + __import_clearDisplaySlot(this.__handle, cast(uint)(slot)); + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]bedrock-scoreboard.clear-display-slot") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:bedrock_scoreboard.clear_display_slot") + static private extern(C) void __import_clearDisplaySlot(uint, uint) nothrow; + + /++ + + +/ + void updateScore(in WitString entityName, in WitString objectiveName, int value) @trusted nothrow { + __import_updateScore(this.__handle, cast(void*)(entityName.ptr), entityName.length, cast(void*)(objectiveName.ptr), objectiveName.length, cast(uint)(value)); + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]bedrock-scoreboard.update-score") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:bedrock_scoreboard.update_score") + static private extern(C) void __import_updateScore(uint, void*, size_t, void*, size_t, uint) nothrow; + + /++ + + +/ + int addScore(in WitString entityName, in WitString objectiveName, int delta) @trusted nothrow { + auto _ret = __import_addScore(this.__handle, cast(void*)(entityName.ptr), entityName.length, cast(void*)(objectiveName.ptr), objectiveName.length, cast(uint)(delta)); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]bedrock-scoreboard.add-score") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:bedrock_scoreboard.add_score") + static private extern(C) uint __import_addScore(uint, void*, size_t, void*, size_t, uint) nothrow; + + /++ + + +/ + void removeScore(in WitString entityName, in WitString objectiveName) @trusted nothrow { + __import_removeScore(this.__handle, cast(void*)(entityName.ptr), entityName.length, cast(void*)(objectiveName.ptr), objectiveName.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]bedrock-scoreboard.remove-score") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:bedrock_scoreboard.remove_score") + static private extern(C) void __import_removeScore(uint, void*, size_t, void*, size_t) nothrow; + + /++ + + +/ + void resetEntityScores(in WitString entityName) @trusted nothrow { + __import_resetEntityScores(this.__handle, cast(void*)(entityName.ptr), entityName.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/scoreboard@0.1.0", "[method]bedrock-scoreboard.reset-entity-scores") + pragma(mangle, "__wit_import_pumpkin:plugin__scoreboard@0.1.0__:method:bedrock_scoreboard.reset_entity_scores") + static private extern(C) void __import_resetEntityScores(uint, void*, size_t) nothrow; + } +} diff --git a/src/wit/pumpkin/plugin/screens/common.d b/src/wit/pumpkin/plugin/screens/common.d new file mode 100644 index 0000000..2f7197b --- /dev/null +++ b/src/wit/pumpkin/plugin/screens/common.d @@ -0,0 +1,140 @@ +/++ + ++/ +module wit.pumpkin.plugin.screens.common; + + +import wit.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +enum Screen : ubyte { + /++ + + +/ + generic9x1, + + /++ + + +/ + generic9x2, + + /++ + + +/ + generic9x3, + + /++ + + +/ + generic9x4, + + /++ + + +/ + generic9x5, + + /++ + + +/ + generic9x6, + + /++ + + +/ + generic3x3, + + /++ + + +/ + crafter3x3, + + /++ + + +/ + anvil, + + /++ + + +/ + beacon, + + /++ + + +/ + blastFurnace, + + /++ + + +/ + brewingStand, + + /++ + + +/ + crafting, + + /++ + + +/ + enchantment, + + /++ + + +/ + furnace, + + /++ + + +/ + grindstone, + + /++ + + +/ + hopper, + + /++ + + +/ + lectern, + + /++ + + +/ + loom, + + /++ + + +/ + merchant, + + /++ + + +/ + shulkerBox, + + /++ + + +/ + smithing, + + /++ + + +/ + smoker, + + /++ + + +/ + cartographyTable, + + /++ + + +/ + stonecutter, +} \ No newline at end of file diff --git a/src/wit/pumpkin/plugin/screens/imports.d b/src/wit/pumpkin/plugin/screens/imports.d new file mode 100644 index 0000000..2a2f929 --- /dev/null +++ b/src/wit/pumpkin/plugin/screens/imports.d @@ -0,0 +1,12 @@ +/++ + ++/ +module wit.pumpkin.plugin.screens.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.screens.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); diff --git a/src/wit/pumpkin/plugin/server/common.d b/src/wit/pumpkin/plugin/server/common.d new file mode 100644 index 0000000..3d1fdef --- /dev/null +++ b/src/wit/pumpkin/plugin/server/common.d @@ -0,0 +1,321 @@ +/++ + ++/ +module wit.pumpkin.plugin.server.common; + + +import wit.common; + +static import wit.pumpkin.plugin.common.common; +static import wit.pumpkin.plugin.datapack.common; +static import wit.pumpkin.plugin.permission.common; +static import wit.pumpkin.plugin.text.common; +static import wit.pumpkin.plugin.advancement.common; +static import wit.pumpkin.plugin.enchantments.common; +static import wit.pumpkin.plugin.recipe.common; +static import wit.pumpkin.plugin.uuid.common; +static import wit.pumpkin.plugin.world.common; +static import wit.pumpkin.plugin.player.common; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias KnownServerLink = wit.pumpkin.plugin.player.common.KnownServerLink; + +/++ + ++/ +alias GameMode = wit.pumpkin.plugin.common.common.GameMode; + +/++ + ++/ +alias Uuid = wit.pumpkin.plugin.uuid.common.Uuid; + +/++ + ++/ +alias PermissionLevel = wit.pumpkin.plugin.permission.common.PermissionLevel; + +/++ + ++/ +alias DatapackInfo = wit.pumpkin.plugin.datapack.common.DatapackInfo; + +/++ +Represents an operator entry in the ops configuration. ++/ +struct OpEntry { + /++ + + +/ + Uuid uuid; + + /++ + + +/ + WitString name; + + /++ + + +/ + PermissionLevel level; + + /++ + + +/ + bool bypassesPlayerLimit; + + void witFree() @nogc nothrow { + name.witFree; + } + + void witDrop() @nogc nothrow { + } + + OpEntry witClone() const @nogc nothrow { + OpEntry clone = void; + clone.uuid = this.uuid.witClone; + clone.name = this.name.witClone; + clone.level = this.level.witClone; + clone.bypassesPlayerLimit = this.bypassesPlayerLimit.witClone; + return clone; + } +} + +/++ +Represents a banned player entry in the ban list. ++/ +struct BannedPlayerEntry { + /++ + + +/ + Uuid uuid; + + /++ + + +/ + WitString name; + + /++ + + +/ + WitString created; + + /++ + + +/ + WitString source; + + /++ + + +/ + Option!(WitString) expires; + + /++ + + +/ + WitString reason; + + void witFree() @nogc nothrow { + name.witFree; + created.witFree; + source.witFree; + expires.witFree; + reason.witFree; + } + + void witDrop() @nogc nothrow { + } + + BannedPlayerEntry witClone() const @nogc nothrow { + BannedPlayerEntry clone = void; + clone.uuid = this.uuid.witClone; + clone.name = this.name.witClone; + clone.created = this.created.witClone; + clone.source = this.source.witClone; + clone.expires = this.expires.witClone; + clone.reason = this.reason.witClone; + return clone; + } +} + +/++ +Represents a banned IP entry in the IP ban list. ++/ +struct BannedIpEntry { + /++ + + +/ + WitString ip; + + /++ + + +/ + WitString created; + + /++ + + +/ + WitString source; + + /++ + + +/ + Option!(WitString) expires; + + /++ + + +/ + WitString reason; + + void witFree() @nogc nothrow { + ip.witFree; + created.witFree; + source.witFree; + expires.witFree; + reason.witFree; + } + + void witDrop() @nogc nothrow { + } + + BannedIpEntry witClone() const @nogc nothrow { + BannedIpEntry clone = void; + clone.ip = this.ip.witClone; + clone.created = this.created.witClone; + clone.source = this.source.witClone; + clone.expires = this.expires.witClone; + clone.reason = this.reason.witClone; + return clone; + } +} + +/++ +Represents a player entry in the server whitelist. ++/ +struct WhitelistEntry { + /++ + + +/ + Uuid uuid; + + /++ + + +/ + WitString name; + + void witFree() @nogc nothrow { + name.witFree; + } + + void witDrop() @nogc nothrow { + } + + WhitelistEntry witClone() const @nogc nothrow { + WhitelistEntry clone = void; + clone.uuid = this.uuid.witClone; + clone.name = this.name.witClone; + return clone; + } +} + +/++ +Represents the difficulty setting of a Minecraft server. ++/ +enum Difficulty : ubyte { + /++ + Hostile mobs do not spawn. Players regain health automatically. + +/ + peaceful, + + /++ + Hostile mobs deal less damage. + +/ + easy, + + /++ + Standard Minecraft difficulty. + +/ + normal, + + /++ + Hostile mobs deal more damage. + +/ + hard, +} +/++ +Represents the three main Minecraft dimensions. ++/ +enum Dimension : ubyte { + /++ + + +/ + overworld, + + /++ + + +/ + nether, + + /++ + + +/ + end, +} +/++ + ++/ +struct SysInfo { + /++ + + +/ + Option!(uint) cpuCount; + + /++ + + +/ + Option!(ulong) totalMemory; + + /++ + + +/ + Option!(ulong) usedMemory; + + /++ + + +/ + Option!(WitString) osName; + + /++ + + +/ + Option!(WitString) osVersion; + + /++ + + +/ + WitString pumpkinVersion; + + void witFree() @nogc nothrow { + osName.witFree; + osVersion.witFree; + pumpkinVersion.witFree; + } + + void witDrop() @nogc nothrow { + } + + SysInfo witClone() const @nogc nothrow { + SysInfo clone = void; + clone.cpuCount = this.cpuCount.witClone; + clone.totalMemory = this.totalMemory.witClone; + clone.usedMemory = this.usedMemory.witClone; + clone.osName = this.osName.witClone; + clone.osVersion = this.osVersion.witClone; + clone.pumpkinVersion = this.pumpkinVersion.witClone; + return clone; + } +} diff --git a/src/wit/pumpkin/plugin/server/imports.d b/src/wit/pumpkin/plugin/server/imports.d new file mode 100644 index 0000000..9ca6253 --- /dev/null +++ b/src/wit/pumpkin/plugin/server/imports.d @@ -0,0 +1,1748 @@ +/++ + ++/ +module wit.pumpkin.plugin.server.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.server.common; + +static import wit.pumpkin.plugin.common.imports; +static import wit.pumpkin.plugin.datapack.imports; +static import wit.pumpkin.plugin.permission.imports; +static import wit.pumpkin.plugin.text.imports; +static import wit.pumpkin.plugin.advancement.imports; +static import wit.pumpkin.plugin.enchantments.imports; +static import wit.pumpkin.plugin.recipe.imports; +static import wit.pumpkin.plugin.uuid.imports; +static import wit.pumpkin.plugin.world.imports; +static import wit.pumpkin.plugin.player.imports; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias Player = wit.pumpkin.plugin.player.imports.Player; + +/++ + ++/ +alias BanPlayerOptions = wit.pumpkin.plugin.player.imports.BanPlayerOptions; + +/++ + ++/ +alias BanIpOptions = wit.pumpkin.plugin.player.imports.BanIpOptions; + +/++ + ++/ +alias ServerLink = wit.pumpkin.plugin.player.imports.ServerLink; + +/++ + ++/ +alias ServerLinkLabel = wit.pumpkin.plugin.player.imports.ServerLinkLabel; + +/++ + ++/ +alias World = wit.pumpkin.plugin.world.imports.World; + +/++ + ++/ +alias TextComponent = wit.pumpkin.plugin.text.imports.TextComponent; + +/++ + ++/ +alias RecipeManager = wit.pumpkin.plugin.recipe.imports.RecipeManager; + +/++ + ++/ +alias EnchantmentManager = wit.pumpkin.plugin.enchantments.imports.EnchantmentManager; + +/++ + ++/ +alias CustomEnchantment = wit.pumpkin.plugin.enchantments.imports.CustomEnchantment; + +/++ + ++/ +alias AdvancementInfo = wit.pumpkin.plugin.advancement.imports.AdvancementInfo; + +/++ + ++/ +alias DatapackManager = wit.pumpkin.plugin.datapack.imports.DatapackManager; + +/++ +Interface for querying and managing server operators. ++/ +struct OpManager { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/server@0.1.0", "[resource-drop]op-manager") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:resource_drop:op_manager") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + Checks if a player UUID is currently an operator. + +/ + bool isOp(in Uuid id) @trusted nothrow { + auto _ret = __import_isOp(this.__handle, id.high, id.low); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]op-manager.is-op") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:op_manager.is_op") + static private extern(C) uint __import_isOp(uint, ulong, ulong) nothrow; + + /++ + Retrieves the operator entry for a player UUID, if present. + +/ + Option!(OpEntry) getOp(in Uuid id) @trusted nothrow { + align(8) void[(32+2*size_t.sizeof)] _retArea = void; + __import_getOp(this.__handle, id.high, id.low, _retArea.ptr); + Option!(OpEntry) _option6 = void; + bool _isSome6 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome6) { + wit.pumpkin.plugin.uuid.imports.Uuid _record2 = { + high: *(cast(ulong*)(_retArea.ptr + 8)), + low: *(cast(ulong*)(_retArea.ptr + 16)), + }; + auto _len3 = *(cast(size_t*)(_retArea.ptr + (24+1*size_t.sizeof))); + auto _ptr3 = _len3 ? cast(char*)(*(cast(void**)(_retArea.ptr + 24))) : null; + auto _list4 = WitString(_ptr3[0.._len3]); + OpEntry _record5 = { + uuid: _record2, + name: _list4, + level: cast(wit.pumpkin.plugin.permission.imports.PermissionLevel)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (24+2*size_t.sizeof))))), + bypassesPlayerLimit: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (25+2*size_t.sizeof))))) != 0, + }; + + _option6 = Option!(OpEntry).makeSome(_record5); + } else { + _option6 = Option!(OpEntry).makeNone; + } + auto _flush7 = _option6; + return _flush7; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]op-manager.get-op") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:op_manager.get_op") + static private extern(C) void __import_getOp(uint, ulong, ulong, void*) nothrow; + + /++ + Gets the effective permission level for a player UUID (returns zero if not op). + +/ + PermissionLevel getPermissionLevel(in Uuid id) @trusted nothrow { + auto _ret = __import_getPermissionLevel(this.__handle, id.high, id.low); + return cast(wit.pumpkin.plugin.permission.imports.PermissionLevel)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]op-manager.get-permission-level") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:op_manager.get_permission_level") + static private extern(C) uint __import_getPermissionLevel(uint, ulong, ulong) nothrow; + + /++ + Grants operator status to a player (online or offline) with the specified level and bypass setting. + +/ + void opPlayer(in WitString name, in Uuid id, PermissionLevel level, bool bypassesPlayerLimit) @trusted nothrow { + __import_opPlayer(this.__handle, cast(void*)(name.ptr), name.length, id.high, id.low, cast(uint)(level), cast(uint)(bypassesPlayerLimit)); + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]op-manager.op-player") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:op_manager.op_player") + static private extern(C) void __import_opPlayer(uint, void*, size_t, ulong, ulong, uint, uint) nothrow; + + /++ + Revokes operator status from a player (online or offline). Returns true if the player was previously op. + +/ + bool deopPlayer(in Uuid id) @trusted nothrow { + auto _ret = __import_deopPlayer(this.__handle, id.high, id.low); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]op-manager.deop-player") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:op_manager.deop_player") + static private extern(C) uint __import_deopPlayer(uint, ulong, ulong) nothrow; + + /++ + Returns a list of all operator entries on the server. + +/ + WitList!(OpEntry) listOps() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_listOps(this.__handle, _retArea.ptr); + auto _listSrcPtr5 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen5 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list5 = _listLen5 ? wit.common.mallocSlice!(OpEntry)(_listLen5) : []; + assert(!_listLen5 || _list5.ptr); + foreach (_elem0_idx, ref _elem0; _list5) { + const auto _base0 = _listSrcPtr5 + _elem0_idx * (24+2*size_t.sizeof); + wit.pumpkin.plugin.uuid.imports.Uuid _record1 = { + high: *(cast(ulong*)(_base0 + 0)), + low: *(cast(ulong*)(_base0 + 8)), + }; + auto _len2 = *(cast(size_t*)(_base0 + (16+1*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_base0 + 16))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + OpEntry _record4 = { + uuid: _record1, + name: _list3, + level: cast(wit.pumpkin.plugin.permission.imports.PermissionLevel)(cast(uint)(*(cast(ubyte*)(_base0 + (16+2*size_t.sizeof))))), + bypassesPlayerLimit: (cast(uint)(*(cast(ubyte*)(_base0 + (17+2*size_t.sizeof))))) != 0, + }; + _elem0 = _record4; + } + if (_listLen5) wit.common.free(_listSrcPtr5); + auto _witList6 = WitList!(OpEntry)(_list5); + auto _flush7 = _witList6; + return _flush7; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]op-manager.list-ops") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:op_manager.list_ops") + static private extern(C) void __import_listOps(uint, void*) nothrow; + } +} + +/++ +Global manager for player and IP bans. ++/ +struct BanManager { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/server@0.1.0", "[resource-drop]ban-manager") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:resource_drop:ban_manager") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + Checks if a player UUID is currently banned. + +/ + bool isPlayerBanned(in Uuid id) @trusted nothrow { + auto _ret = __import_isPlayerBanned(this.__handle, id.high, id.low); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]ban-manager.is-player-banned") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:ban_manager.is_player_banned") + static private extern(C) uint __import_isPlayerBanned(uint, ulong, ulong) nothrow; + + /++ + Retrieves the ban entry for a player UUID, if banned. + +/ + Option!(BannedPlayerEntry) getPlayerBan(in Uuid id) @trusted nothrow { + align(8) void[(32+10*size_t.sizeof)] _retArea = void; + __import_getPlayerBan(this.__handle, id.high, id.low, _retArea.ptr); + Option!(BannedPlayerEntry) _option17 = void; + bool _isSome17 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome17) { + wit.pumpkin.plugin.uuid.imports.Uuid _record2 = { + high: *(cast(ulong*)(_retArea.ptr + 8)), + low: *(cast(ulong*)(_retArea.ptr + 16)), + }; + auto _len3 = *(cast(size_t*)(_retArea.ptr + (24+1*size_t.sizeof))); + auto _ptr3 = _len3 ? cast(char*)(*(cast(void**)(_retArea.ptr + 24))) : null; + auto _list4 = WitString(_ptr3[0.._len3]); + auto _len5 = *(cast(size_t*)(_retArea.ptr + (24+3*size_t.sizeof))); + auto _ptr5 = _len5 ? cast(char*)(*(cast(void**)(_retArea.ptr + (24+2*size_t.sizeof)))) : null; + auto _list6 = WitString(_ptr5[0.._len5]); + auto _len7 = *(cast(size_t*)(_retArea.ptr + (24+5*size_t.sizeof))); + auto _ptr7 = _len7 ? cast(char*)(*(cast(void**)(_retArea.ptr + (24+4*size_t.sizeof)))) : null; + auto _list8 = WitString(_ptr7[0.._len7]); + Option!(WitString) _option13 = void; + bool _isSome13 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (24+6*size_t.sizeof))))) != 0; + if (_isSome13) { + auto _len11 = *(cast(size_t*)(_retArea.ptr + (24+8*size_t.sizeof))); + auto _ptr11 = _len11 ? cast(char*)(*(cast(void**)(_retArea.ptr + (24+7*size_t.sizeof)))) : null; + auto _list12 = WitString(_ptr11[0.._len11]); + + _option13 = Option!(WitString).makeSome(_list12); + } else { + _option13 = Option!(WitString).makeNone; + } + auto _len14 = *(cast(size_t*)(_retArea.ptr + (24+10*size_t.sizeof))); + auto _ptr14 = _len14 ? cast(char*)(*(cast(void**)(_retArea.ptr + (24+9*size_t.sizeof)))) : null; + auto _list15 = WitString(_ptr14[0.._len14]); + BannedPlayerEntry _record16 = { + uuid: _record2, + name: _list4, + created: _list6, + source: _list8, + expires: _option13, + reason: _list15, + }; + + _option17 = Option!(BannedPlayerEntry).makeSome(_record16); + } else { + _option17 = Option!(BannedPlayerEntry).makeNone; + } + auto _flush18 = _option17; + return _flush18; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]ban-manager.get-player-ban") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:ban_manager.get_player_ban") + static private extern(C) void __import_getPlayerBan(uint, ulong, ulong, void*) nothrow; + + /++ + Bans a player by name and UUID with the specified options (works for online and offline players). + +/ + void banPlayer(in WitString name, in Uuid id, in BanPlayerOptions options) @trusted nothrow { + align(8) void[(56+8*size_t.sizeof)] _retArea = void; + *cast(uint*)(_retArea.ptr + 0) = cast(uint)(this.__handle); + *cast(size_t*)(_retArea.ptr + (2*size_t.sizeof)) = cast(size_t)(name.length); + *cast(void**)(_retArea.ptr + size_t.sizeof) = cast(void*)(cast(void*)(name.ptr)); + *cast(ulong*)(_retArea.ptr + (8+2*size_t.sizeof)) = cast(ulong)(id.high); + *cast(ulong*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(ulong)(id.low); + if (options.reason.isSome) { + ref _payload3 = options.reason.unwrap(); + *cast(ubyte*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(ubyte)(1); + *cast(uint*)(_retArea.ptr + (28+2*size_t.sizeof)) = cast(uint)(_payload3.__handle); + } else { + *cast(ubyte*)(_retArea.ptr + (24+2*size_t.sizeof)) = cast(ubyte)(0); + } + if (options.source.isSome) { + ref _payload7 = options.source.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+4*size_t.sizeof)) = cast(size_t)(_payload7.length); + *cast(void**)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(void*)(cast(void*)(_payload7.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (32+2*size_t.sizeof)) = cast(ubyte)(0); + } + if (options.expiresAtUtc.isSome) { + ref _payload11 = options.expiresAtUtc.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+5*size_t.sizeof)) = cast(ubyte)(1); + *cast(size_t*)(_retArea.ptr + (32+7*size_t.sizeof)) = cast(size_t)(_payload11.length); + *cast(void**)(_retArea.ptr + (32+6*size_t.sizeof)) = cast(void*)(cast(void*)(_payload11.ptr)); + } else { + *cast(ubyte*)(_retArea.ptr + (32+5*size_t.sizeof)) = cast(ubyte)(0); + } + if (options.durationSeconds.isSome) { + ref _payload15 = options.durationSeconds.unwrap(); + *cast(ubyte*)(_retArea.ptr + (32+8*size_t.sizeof)) = cast(ubyte)(1); + *cast(ulong*)(_retArea.ptr + (40+8*size_t.sizeof)) = cast(ulong)(_payload15); + } else { + *cast(ubyte*)(_retArea.ptr + (32+8*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + (48+8*size_t.sizeof)) = cast(ubyte)(cast(uint)(options.kickIfOnline)); + *cast(ubyte*)(_retArea.ptr + (49+8*size_t.sizeof)) = cast(ubyte)(cast(uint)(options.logToConsole)); + __import_banPlayer(_retArea.ptr); + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]ban-manager.ban-player") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:ban_manager.ban_player") + static private extern(C) void __import_banPlayer(void*) nothrow; + + /++ + Removes a player ban by UUID. Returns true if the player was banned. + +/ + bool unbanPlayer(in Uuid id) @trusted nothrow { + auto _ret = __import_unbanPlayer(this.__handle, id.high, id.low); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]ban-manager.unban-player") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:ban_manager.unban_player") + static private extern(C) uint __import_unbanPlayer(uint, ulong, ulong) nothrow; + + /++ + Returns all currently active player bans. + +/ + WitList!(BannedPlayerEntry) listPlayerBans() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_listPlayerBans(this.__handle, _retArea.ptr); + auto _listSrcPtr16 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen16 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list16 = _listLen16 ? wit.common.mallocSlice!(BannedPlayerEntry)(_listLen16) : []; + assert(!_listLen16 || _list16.ptr); + foreach (_elem0_idx, ref _elem0; _list16) { + const auto _base0 = _listSrcPtr16 + _elem0_idx * (24+10*size_t.sizeof); + wit.pumpkin.plugin.uuid.imports.Uuid _record1 = { + high: *(cast(ulong*)(_base0 + 0)), + low: *(cast(ulong*)(_base0 + 8)), + }; + auto _len2 = *(cast(size_t*)(_base0 + (16+1*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_base0 + 16))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + auto _len4 = *(cast(size_t*)(_base0 + (16+3*size_t.sizeof))); + auto _ptr4 = _len4 ? cast(char*)(*(cast(void**)(_base0 + (16+2*size_t.sizeof)))) : null; + auto _list5 = WitString(_ptr4[0.._len4]); + auto _len6 = *(cast(size_t*)(_base0 + (16+5*size_t.sizeof))); + auto _ptr6 = _len6 ? cast(char*)(*(cast(void**)(_base0 + (16+4*size_t.sizeof)))) : null; + auto _list7 = WitString(_ptr6[0.._len6]); + Option!(WitString) _option12 = void; + bool _isSome12 = (cast(uint)(*(cast(ubyte*)(_base0 + (16+6*size_t.sizeof))))) != 0; + if (_isSome12) { + auto _len10 = *(cast(size_t*)(_base0 + (16+8*size_t.sizeof))); + auto _ptr10 = _len10 ? cast(char*)(*(cast(void**)(_base0 + (16+7*size_t.sizeof)))) : null; + auto _list11 = WitString(_ptr10[0.._len10]); + + _option12 = Option!(WitString).makeSome(_list11); + } else { + _option12 = Option!(WitString).makeNone; + } + auto _len13 = *(cast(size_t*)(_base0 + (16+10*size_t.sizeof))); + auto _ptr13 = _len13 ? cast(char*)(*(cast(void**)(_base0 + (16+9*size_t.sizeof)))) : null; + auto _list14 = WitString(_ptr13[0.._len13]); + BannedPlayerEntry _record15 = { + uuid: _record1, + name: _list3, + created: _list5, + source: _list7, + expires: _option12, + reason: _list14, + }; + _elem0 = _record15; + } + if (_listLen16) wit.common.free(_listSrcPtr16); + auto _witList17 = WitList!(BannedPlayerEntry)(_list16); + auto _flush18 = _witList17; + return _flush18; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]ban-manager.list-player-bans") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:ban_manager.list_player_bans") + static private extern(C) void __import_listPlayerBans(uint, void*) nothrow; + + /++ + Checks if an IP address is currently banned. + +/ + bool isIpBanned(in WitString ip) @trusted nothrow { + auto _ret = __import_isIpBanned(this.__handle, cast(void*)(ip.ptr), ip.length); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]ban-manager.is-ip-banned") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:ban_manager.is_ip_banned") + static private extern(C) uint __import_isIpBanned(uint, void*, size_t) nothrow; + + /++ + Retrieves the ban entry for an IP address, if banned. + +/ + Option!(BannedIpEntry) getIpBan(in WitString ip) @trusted nothrow { + align(size_t.sizeof) void[(12*size_t.sizeof)] _retArea = void; + __import_getIpBan(this.__handle, cast(void*)(ip.ptr), ip.length, _retArea.ptr); + Option!(BannedIpEntry) _option16 = void; + bool _isSome16 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome16) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + auto _len4 = *(cast(size_t*)(_retArea.ptr + (4*size_t.sizeof))); + auto _ptr4 = _len4 ? cast(char*)(*(cast(void**)(_retArea.ptr + (3*size_t.sizeof)))) : null; + auto _list5 = WitString(_ptr4[0.._len4]); + auto _len6 = *(cast(size_t*)(_retArea.ptr + (6*size_t.sizeof))); + auto _ptr6 = _len6 ? cast(char*)(*(cast(void**)(_retArea.ptr + (5*size_t.sizeof)))) : null; + auto _list7 = WitString(_ptr6[0.._len6]); + Option!(WitString) _option12 = void; + bool _isSome12 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (7*size_t.sizeof))))) != 0; + if (_isSome12) { + auto _len10 = *(cast(size_t*)(_retArea.ptr + (9*size_t.sizeof))); + auto _ptr10 = _len10 ? cast(char*)(*(cast(void**)(_retArea.ptr + (8*size_t.sizeof)))) : null; + auto _list11 = WitString(_ptr10[0.._len10]); + + _option12 = Option!(WitString).makeSome(_list11); + } else { + _option12 = Option!(WitString).makeNone; + } + auto _len13 = *(cast(size_t*)(_retArea.ptr + (11*size_t.sizeof))); + auto _ptr13 = _len13 ? cast(char*)(*(cast(void**)(_retArea.ptr + (10*size_t.sizeof)))) : null; + auto _list14 = WitString(_ptr13[0.._len13]); + BannedIpEntry _record15 = { + ip: _list3, + created: _list5, + source: _list7, + expires: _option12, + reason: _list14, + }; + + _option16 = Option!(BannedIpEntry).makeSome(_record15); + } else { + _option16 = Option!(BannedIpEntry).makeNone; + } + auto _flush17 = _option16; + return _flush17; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]ban-manager.get-ip-ban") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:ban_manager.get_ip_ban") + static private extern(C) void __import_getIpBan(uint, void*, size_t, void*) nothrow; + + /++ + Bans an IP address with the specified options. + +/ + void banIp(in WitString ip, in BanIpOptions options) @trusted nothrow { + uint _option4 = void; + uint _option5 = void; + if (options.reason.isSome) { + ref _payload3 = options.reason.unwrap(); + _option4 = 1; + _option5 = _payload3.__handle; + } else { + _option4 = 0; + _option5 = 0; + } + uint _option10 = void; + void* _option11 = void; + size_t _option12 = void; + if (options.source.isSome) { + ref _payload9 = options.source.unwrap(); + _option10 = 1; + _option11 = cast(void*)(_payload9.ptr); + _option12 = _payload9.length; + } else { + _option10 = 0; + _option11 = null; + _option12 = 0; + } + uint _option17 = void; + void* _option18 = void; + size_t _option19 = void; + if (options.expiresAtUtc.isSome) { + ref _payload16 = options.expiresAtUtc.unwrap(); + _option17 = 1; + _option18 = cast(void*)(_payload16.ptr); + _option19 = _payload16.length; + } else { + _option17 = 0; + _option18 = null; + _option19 = 0; + } + uint _option24 = void; + ulong _option25 = void; + if (options.durationSeconds.isSome) { + ref _payload23 = options.durationSeconds.unwrap(); + _option24 = 1; + _option25 = _payload23; + } else { + _option24 = 0; + _option25 = 0; + } + __import_banIp(this.__handle, cast(void*)(ip.ptr), ip.length, _option4, _option5, _option10, _option11, _option12, _option17, _option18, _option19, _option24, _option25, cast(uint)(options.kickMatchingPlayers), cast(uint)(options.logToConsole)); + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]ban-manager.ban-ip") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:ban_manager.ban_ip") + static private extern(C) void __import_banIp(uint, void*, size_t, uint, uint, uint, void*, size_t, uint, void*, size_t, uint, ulong, uint, uint) nothrow; + + /++ + Removes an IP ban. Returns true if the IP was banned. + +/ + bool unbanIp(in WitString ip) @trusted nothrow { + auto _ret = __import_unbanIp(this.__handle, cast(void*)(ip.ptr), ip.length); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]ban-manager.unban-ip") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:ban_manager.unban_ip") + static private extern(C) uint __import_unbanIp(uint, void*, size_t) nothrow; + + /++ + Returns all currently active IP bans. + +/ + WitList!(BannedIpEntry) listIpBans() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_listIpBans(this.__handle, _retArea.ptr); + auto _listSrcPtr15 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen15 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list15 = _listLen15 ? wit.common.mallocSlice!(BannedIpEntry)(_listLen15) : []; + assert(!_listLen15 || _list15.ptr); + foreach (_elem0_idx, ref _elem0; _list15) { + const auto _base0 = _listSrcPtr15 + _elem0_idx * (11*size_t.sizeof); + auto _len1 = *(cast(size_t*)(_base0 + size_t.sizeof)); + auto _ptr1 = _len1 ? cast(char*)(*(cast(void**)(_base0 + 0))) : null; + auto _list2 = WitString(_ptr1[0.._len1]); + auto _len3 = *(cast(size_t*)(_base0 + (3*size_t.sizeof))); + auto _ptr3 = _len3 ? cast(char*)(*(cast(void**)(_base0 + (2*size_t.sizeof)))) : null; + auto _list4 = WitString(_ptr3[0.._len3]); + auto _len5 = *(cast(size_t*)(_base0 + (5*size_t.sizeof))); + auto _ptr5 = _len5 ? cast(char*)(*(cast(void**)(_base0 + (4*size_t.sizeof)))) : null; + auto _list6 = WitString(_ptr5[0.._len5]); + Option!(WitString) _option11 = void; + bool _isSome11 = (cast(uint)(*(cast(ubyte*)(_base0 + (6*size_t.sizeof))))) != 0; + if (_isSome11) { + auto _len9 = *(cast(size_t*)(_base0 + (8*size_t.sizeof))); + auto _ptr9 = _len9 ? cast(char*)(*(cast(void**)(_base0 + (7*size_t.sizeof)))) : null; + auto _list10 = WitString(_ptr9[0.._len9]); + + _option11 = Option!(WitString).makeSome(_list10); + } else { + _option11 = Option!(WitString).makeNone; + } + auto _len12 = *(cast(size_t*)(_base0 + (10*size_t.sizeof))); + auto _ptr12 = _len12 ? cast(char*)(*(cast(void**)(_base0 + (9*size_t.sizeof)))) : null; + auto _list13 = WitString(_ptr12[0.._len12]); + BannedIpEntry _record14 = { + ip: _list2, + created: _list4, + source: _list6, + expires: _option11, + reason: _list13, + }; + _elem0 = _record14; + } + if (_listLen15) wit.common.free(_listSrcPtr15); + auto _witList16 = WitList!(BannedIpEntry)(_list15); + auto _flush17 = _witList16; + return _flush17; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]ban-manager.list-ip-bans") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:ban_manager.list_ip_bans") + static private extern(C) void __import_listIpBans(uint, void*) nothrow; + } +} + +/++ +Global manager for the server whitelist. ++/ +struct WhitelistManager { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/server@0.1.0", "[resource-drop]whitelist-manager") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:resource_drop:whitelist_manager") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + Returns whether the whitelist is currently enabled. + +/ + bool isEnabled() @trusted nothrow { + auto _ret = __import_isEnabled(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]whitelist-manager.is-enabled") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:whitelist_manager.is_enabled") + static private extern(C) uint __import_isEnabled(uint) nothrow; + + /++ + Enables or disables the server whitelist. If enabled and enforce-whitelist is set, kicks non-whitelisted players. + +/ + void setEnabled(bool enabled) @trusted nothrow { + __import_setEnabled(this.__handle, cast(uint)(enabled)); + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]whitelist-manager.set-enabled") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:whitelist_manager.set_enabled") + static private extern(C) void __import_setEnabled(uint, uint) nothrow; + + /++ + Checks if a player UUID is on the whitelist. + +/ + bool isWhitelisted(in Uuid id) @trusted nothrow { + auto _ret = __import_isWhitelisted(this.__handle, id.high, id.low); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]whitelist-manager.is-whitelisted") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:whitelist_manager.is_whitelisted") + static private extern(C) uint __import_isWhitelisted(uint, ulong, ulong) nothrow; + + /++ + Adds a player to the whitelist (online or offline). Returns true if newly added. + +/ + bool addPlayer(in WitString name, in Uuid id) @trusted nothrow { + auto _ret = __import_addPlayer(this.__handle, cast(void*)(name.ptr), name.length, id.high, id.low); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]whitelist-manager.add-player") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:whitelist_manager.add_player") + static private extern(C) uint __import_addPlayer(uint, void*, size_t, ulong, ulong) nothrow; + + /++ + Removes a player from the whitelist. Returns true if the player was on the whitelist. + +/ + bool removePlayer(in Uuid id) @trusted nothrow { + auto _ret = __import_removePlayer(this.__handle, id.high, id.low); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]whitelist-manager.remove-player") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:whitelist_manager.remove_player") + static private extern(C) uint __import_removePlayer(uint, ulong, ulong) nothrow; + + /++ + Returns all whitelisted player entries. + +/ + WitList!(WhitelistEntry) listEntries() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_listEntries(this.__handle, _retArea.ptr); + auto _listSrcPtr5 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen5 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list5 = _listLen5 ? wit.common.mallocSlice!(WhitelistEntry)(_listLen5) : []; + assert(!_listLen5 || _list5.ptr); + foreach (_elem0_idx, ref _elem0; _list5) { + const auto _base0 = _listSrcPtr5 + _elem0_idx * (16+2*size_t.sizeof); + wit.pumpkin.plugin.uuid.imports.Uuid _record1 = { + high: *(cast(ulong*)(_base0 + 0)), + low: *(cast(ulong*)(_base0 + 8)), + }; + auto _len2 = *(cast(size_t*)(_base0 + (16+1*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_base0 + 16))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + WhitelistEntry _record4 = { + uuid: _record1, + name: _list3, + }; + _elem0 = _record4; + } + if (_listLen5) wit.common.free(_listSrcPtr5); + auto _witList6 = WitList!(WhitelistEntry)(_list5); + auto _flush7 = _witList6; + return _flush7; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]whitelist-manager.list-entries") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:whitelist_manager.list_entries") + static private extern(C) void __import_listEntries(uint, void*) nothrow; + } +} + +/++ + ++/ +struct CommandSender { + mixin WitVariant!( + void, // console + Player, // player + ); + +public: + enum Tag : ubyte { + /++ + + +/ + console, + + /++ + + +/ + player, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias console = _create!(Tag.console); + /// ditto + pragma(inline, true) bool isConsole() const => _tag == Tag.console; + + /++ + + +/ + alias player = _create!(Tag.player); + /// ditto + pragma(inline, true) bool isPlayer() const => _tag == Tag.player; + ///ditto + alias getPlayer = _get!(Tag.player); + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + switch (_tag) with (Tag) { + case player: _get!(Tag.player).witDrop; break; + default: break; + } + } + + CommandSender witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.console: return _create!(Tag.console); break; + case Tag.player: return _create!(Tag.player)(this._get!(Tag.player).witClone); break; + } + } +} + +/++ +Represents the global server instance. ++/ +struct Server { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/server@0.1.0", "[resource-drop]server") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:resource_drop:server") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + Returns system information (CPU, Memory, OS). + Fields are returned only if the plugin has the corresponding permissions. + +/ + SysInfo getSysInfo() @trusted nothrow { + align(8) void[(40+8*size_t.sizeof)] _retArea = void; + __import_getSysInfo(this.__handle, _retArea.ptr); + Option!(uint) _option2 = void; + bool _isSome2 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome2) { + + _option2 = Option!(uint).makeSome(*(cast(uint*)(_retArea.ptr + 4))); + } else { + _option2 = Option!(uint).makeNone; + } + Option!(ulong) _option5 = void; + bool _isSome5 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 8)))) != 0; + if (_isSome5) { + + _option5 = Option!(ulong).makeSome(*(cast(ulong*)(_retArea.ptr + 16))); + } else { + _option5 = Option!(ulong).makeNone; + } + Option!(ulong) _option8 = void; + bool _isSome8 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 24)))) != 0; + if (_isSome8) { + + _option8 = Option!(ulong).makeSome(*(cast(ulong*)(_retArea.ptr + 32))); + } else { + _option8 = Option!(ulong).makeNone; + } + Option!(WitString) _option13 = void; + bool _isSome13 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 40)))) != 0; + if (_isSome13) { + auto _len11 = *(cast(size_t*)(_retArea.ptr + (40+2*size_t.sizeof))); + auto _ptr11 = _len11 ? cast(char*)(*(cast(void**)(_retArea.ptr + (40+1*size_t.sizeof)))) : null; + auto _list12 = WitString(_ptr11[0.._len11]); + + _option13 = Option!(WitString).makeSome(_list12); + } else { + _option13 = Option!(WitString).makeNone; + } + Option!(WitString) _option18 = void; + bool _isSome18 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (40+3*size_t.sizeof))))) != 0; + if (_isSome18) { + auto _len16 = *(cast(size_t*)(_retArea.ptr + (40+5*size_t.sizeof))); + auto _ptr16 = _len16 ? cast(char*)(*(cast(void**)(_retArea.ptr + (40+4*size_t.sizeof)))) : null; + auto _list17 = WitString(_ptr16[0.._len16]); + + _option18 = Option!(WitString).makeSome(_list17); + } else { + _option18 = Option!(WitString).makeNone; + } + auto _len19 = *(cast(size_t*)(_retArea.ptr + (40+7*size_t.sizeof))); + auto _ptr19 = _len19 ? cast(char*)(*(cast(void**)(_retArea.ptr + (40+6*size_t.sizeof)))) : null; + auto _list20 = WitString(_ptr19[0.._len19]); + SysInfo _record21 = { + cpuCount: _option2, + totalMemory: _option5, + usedMemory: _option8, + osName: _option13, + osVersion: _option18, + pumpkinVersion: _list20, + }; + auto _flush22 = _record21; + return _flush22; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-sys-info") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_sys_info") + static private extern(C) void __import_getSysInfo(uint, void*) nothrow; + + /++ + Returns the current difficulty level of the server. + +/ + Difficulty getDifficulty() @trusted nothrow { + auto _ret = __import_getDifficulty(this.__handle); + return cast(Difficulty)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-difficulty") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_difficulty") + static private extern(C) uint __import_getDifficulty(uint) nothrow; + + /++ + Returns the total number of players currently connected to the server. + +/ + uint getPlayerCount() @trusted nothrow { + auto _ret = __import_getPlayerCount(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-player-count") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_player_count") + static private extern(C) uint __import_getPlayerCount(uint) nothrow; + + /++ + Returns the rolling average Milliseconds Per Tick (MSPT). + A value below 50.0 is required for a stable 20 TPS. + +/ + double getMspt() @trusted nothrow { + auto _ret = __import_getMspt(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-mspt") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_mspt") + static private extern(C) double __import_getMspt(uint) nothrow; + + /++ + Returns the effective Ticks Per Second (TPS). + Ideal value is 20.0. + +/ + double getTps() @trusted nothrow { + auto _ret = __import_getTps(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-tps") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_tps") + static private extern(C) double __import_getTps(uint) nothrow; + + /++ + Returns a list of all online players across all worlds. + +/ + WitList!(Player) getAllPlayers() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getAllPlayers(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(Player*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitList!(Player)(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-all-players") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_all_players") + static private extern(C) void __import_getAllPlayers(uint, void*) nothrow; + + /++ + Searches for a player by their exact name. + +/ + Option!(Player) getPlayerByName(in WitString name) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getPlayerByName(this.__handle, cast(void*)(name.ptr), name.length, _retArea.ptr); + Option!(Player) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = Player(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(Player).makeSome(_handle2); + } else { + _option3 = Option!(Player).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-player-by-name") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_player_by_name") + static private extern(C) void __import_getPlayerByName(uint, void*, size_t, void*) nothrow; + + /++ + Searches for a player by their UUID string. + +/ + Option!(Player) getPlayerByUuid(in Uuid id) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getPlayerByUuid(this.__handle, id.high, id.low, _retArea.ptr); + Option!(Player) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = Player(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(Player).makeSome(_handle2); + } else { + _option3 = Option!(Player).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-player-by-uuid") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_player_by_uuid") + static private extern(C) void __import_getPlayerByUuid(uint, ulong, ulong, void*) nothrow; + + /++ + Returns a list of all worlds on this server. + +/ + WitList!(World) getAllWorlds() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getAllWorlds(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(World*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitList!(World)(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-all-worlds") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_all_worlds") + static private extern(C) void __import_getAllWorlds(uint, void*) nothrow; + + /++ + Gets a world by its dimension name (e.g., "minecraft:overworld") or custom world name (e.g., "world", "arena_1"). + +/ + Option!(World) getWorldByName(in WitString name) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getWorldByName(this.__handle, cast(void*)(name.ptr), name.length, _retArea.ptr); + Option!(World) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = World(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(World).makeSome(_handle2); + } else { + _option3 = Option!(World).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-world-by-name") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_world_by_name") + static private extern(C) void __import_getWorldByName(uint, void*, size_t, void*) nothrow; + + /++ + Checks if a world exists by name or dimension. + +/ + bool hasWorld(in WitString name) @trusted nothrow { + auto _ret = __import_hasWorld(this.__handle, cast(void*)(name.ptr), name.length); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.has-world") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.has_world") + static private extern(C) uint __import_hasWorld(uint, void*, size_t) nothrow; + + /++ + + +/ + void executeCommand(in WitString command, in CommandSender sender) @trusted nothrow { + uint _variantPart4 = void; + uint _variantPart5 = void; + alias _Tag6 = CommandSender.Tag; + final switch (sender.tag) { + case _Tag6.console: { + _variantPart4 = 0; + _variantPart5 = 0; + break; + } + case _Tag6.player: { + const ref Player _payload3 = sender.getPlayer(); + _variantPart4 = 1; + _variantPart5 = _payload3.__handle; + break; + } + } + __import_executeCommand(this.__handle, cast(void*)(command.ptr), command.length, _variantPart4, _variantPart5); + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.execute-command") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.execute_command") + static private extern(C) void __import_executeCommand(uint, void*, size_t, uint, uint) nothrow; + + /++ + Creates or loads a world by its name and dimension. + If a world with the given name already exists, it will be returned. + +/ + World createWorld(in WitString name, Dimension dimension) @trusted nothrow { + auto _ret = __import_createWorld(this.__handle, cast(void*)(name.ptr), name.length, cast(uint)(dimension)); + auto _handle0 = World(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.create-world") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.create_world") + static private extern(C) uint __import_createWorld(uint, void*, size_t, uint) nothrow; + + /++ + Unloads and saves a world by its name or dimension. + Returns an error if the world cannot be found, is the primary/default world, or still has players inside. + +/ + Result!(void, WitString) unloadWorld(in WitString name) @trusted nothrow { + align(size_t.sizeof) void[(3*size_t.sizeof)] _retArea = void; + __import_unloadWorld(this.__handle, cast(void*)(name.ptr), name.length, _retArea.ptr); + Result!(void, WitString) _result4 = void; + bool _isErr4 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isErr4) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + + _result4 = Result!(void, WitString).makeErr(_list3); + } else { + + _result4 = Result!(void, WitString).makeOk(); + } + auto _flush5 = _result4; + return _flush5; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.unload-world") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.unload_world") + static private extern(C) void __import_unloadWorld(uint, void*, size_t, void*) nothrow; + + /++ + Saves all players, player advancements, and loaded worlds to disk. + +/ + Result!(void, WitString) saveAll() @trusted nothrow { + align(size_t.sizeof) void[(3*size_t.sizeof)] _retArea = void; + __import_saveAll(this.__handle, _retArea.ptr); + Result!(void, WitString) _result4 = void; + bool _isErr4 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isErr4) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + + _result4 = Result!(void, WitString).makeErr(_list3); + } else { + + _result4 = Result!(void, WitString).makeOk(); + } + auto _flush5 = _result4; + return _flush5; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.save-all") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.save_all") + static private extern(C) void __import_saveAll(uint, void*) nothrow; + + /++ + Returns a list of all online players in a specific world. + +/ + WitList!(Player) getPlayersInWorld(World worldRef) @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getPlayersInWorld(this.__handle, worldRef.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(Player*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitList!(Player)(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-players-in-world") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_players_in_world") + static private extern(C) void __import_getPlayersInWorld(uint, uint, void*) nothrow; + + /++ + Returns the number of online players in a specific world. + +/ + uint getPlayerCountInWorld(World worldRef) @trusted nothrow { + auto _ret = __import_getPlayerCountInWorld(this.__handle, worldRef.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-player-count-in-world") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_player_count_in_world") + static private extern(C) uint __import_getPlayerCountInWorld(uint, uint) nothrow; + + /++ + Broadcasts a system chat message to all players. + +/ + void broadcast(in WitString message) @trusted nothrow { + __import_broadcast(this.__handle, cast(void*)(message.ptr), message.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.broadcast") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.broadcast") + static private extern(C) void __import_broadcast(uint, void*, size_t) nothrow; + + /++ + Deletes a signed chat message from all players' chat windows using its 256-byte signature. + +/ + void deleteMessageBySignature(in WitList!(ubyte) signature) @trusted nothrow { + __import_deleteMessageBySignature(this.__handle, cast(void*)(signature.ptr), signature.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.delete-message-by-signature") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.delete_message_by_signature") + static private extern(C) void __import_deleteMessageBySignature(uint, void*, size_t) nothrow; + + /++ + Deletes a signed chat message from all players' chat windows using its signature cache ID. + +/ + void deleteMessageById(int signatureId) @trusted nothrow { + __import_deleteMessageById(this.__handle, cast(uint)(signatureId)); + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.delete-message-by-id") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.delete_message_by_id") + static private extern(C) void __import_deleteMessageById(uint, uint) nothrow; + + /++ + Broadcasts a tab list header and footer to all players. + +/ + void broadcastTabListHeaderFooter(TextComponent header, TextComponent footer) @trusted nothrow { + __import_broadcastTabListHeaderFooter(this.__handle, header.__handle, footer.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.broadcast-tab-list-header-footer") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.broadcast_tab_list_header_footer") + static private extern(C) void __import_broadcastTabListHeaderFooter(uint, uint, uint) nothrow; + + /++ + Returns the maximum number of players allowed on the server. + +/ + uint getMaxPlayers() @trusted nothrow { + auto _ret = __import_getMaxPlayers(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-max-players") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_max_players") + static private extern(C) uint __import_getMaxPlayers(uint) nothrow; + + /++ + Returns whether the server is in hardcore mode. + +/ + bool isHardcore() @trusted nothrow { + auto _ret = __import_isHardcore(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.is-hardcore") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.is_hardcore") + static private extern(C) uint __import_isHardcore(uint) nothrow; + + /++ + Returns whether the server is in online mode (authenticates with Mojang). + +/ + bool isOnlineMode() @trusted nothrow { + auto _ret = __import_isOnlineMode(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.is-online-mode") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.is_online_mode") + static private extern(C) uint __import_isOnlineMode(uint) nothrow; + + /++ + Returns the server's Message of the Day (MOTD). + +/ + WitString getMotd() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getMotd(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-motd") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_motd") + static private extern(C) void __import_getMotd(uint, void*) nothrow; + + /++ + Returns whether the server has a whitelist enabled. + +/ + bool hasWhitelist() @trusted nothrow { + auto _ret = __import_hasWhitelist(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.has-whitelist") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.has_whitelist") + static private extern(C) uint __import_hasWhitelist(uint) nothrow; + + /++ + Returns whether the server allows the Nether dimension. + +/ + bool getAllowNether() @trusted nothrow { + auto _ret = __import_getAllowNether(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-allow-nether") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_allow_nether") + static private extern(C) uint __import_getAllowNether(uint) nothrow; + + /++ + Returns whether the server allows the End dimension. + +/ + bool getAllowEnd() @trusted nothrow { + auto _ret = __import_getAllowEnd(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-allow-end") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_allow_end") + static private extern(C) uint __import_getAllowEnd(uint) nothrow; + + /++ + Returns the server's maximum view distance. + +/ + ubyte getViewDistance() @trusted nothrow { + auto _ret = __import_getViewDistance(this.__handle); + return cast(ubyte)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-view-distance") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_view_distance") + static private extern(C) uint __import_getViewDistance(uint) nothrow; + + /++ + Returns the server's maximum simulation distance. + +/ + ubyte getSimulationDistance() @trusted nothrow { + auto _ret = __import_getSimulationDistance(this.__handle); + return cast(ubyte)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-simulation-distance") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_simulation_distance") + static private extern(C) uint __import_getSimulationDistance(uint) nothrow; + + /++ + Returns the server's default gamemode. + +/ + GameMode getDefaultGamemode() @trusted nothrow { + auto _ret = __import_getDefaultGamemode(this.__handle); + return cast(wit.pumpkin.plugin.common.imports.GameMode)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-default-gamemode") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_default_gamemode") + static private extern(C) uint __import_getDefaultGamemode(uint) nothrow; + + /++ + Returns the recipe manager to register custom recipes. + +/ + RecipeManager getRecipeManager() @trusted nothrow { + auto _ret = __import_getRecipeManager(this.__handle); + auto _handle0 = RecipeManager(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-recipe-manager") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_recipe_manager") + static private extern(C) uint __import_getRecipeManager(uint) nothrow; + + /++ + Returns the operator manager to query or modify server operators. + +/ + OpManager getOpManager() @trusted nothrow { + auto _ret = __import_getOpManager(this.__handle); + auto _handle0 = OpManager(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-op-manager") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_op_manager") + static private extern(C) uint __import_getOpManager(uint) nothrow; + + /++ + Returns the global ban manager for querying and modifying player and IP bans. + +/ + BanManager getBanManager() @trusted nothrow { + auto _ret = __import_getBanManager(this.__handle); + auto _handle0 = BanManager(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-ban-manager") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_ban_manager") + static private extern(C) uint __import_getBanManager(uint) nothrow; + + /++ + Returns the global whitelist manager for querying and modifying the server whitelist. + +/ + WhitelistManager getWhitelistManager() @trusted nothrow { + auto _ret = __import_getWhitelistManager(this.__handle); + auto _handle0 = WhitelistManager(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-whitelist-manager") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_whitelist_manager") + static private extern(C) uint __import_getWhitelistManager(uint) nothrow; + + /++ + Returns detailed information about an advancement by its ID (e.g., "minecraft:story/mine_stone" or "story/mine_stone"). + +/ + Option!(AdvancementInfo) getAdvancement(in WitString id) @trusted nothrow { + align(size_t.sizeof) void[(16+13*size_t.sizeof)] _retArea = void; + __import_getAdvancement(this.__handle, cast(void*)(id.ptr), id.length, _retArea.ptr); + Option!(AdvancementInfo) _option26 = void; + bool _isSome26 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome26) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + Option!(WitString) _option8 = void; + bool _isSome8 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (3*size_t.sizeof))))) != 0; + if (_isSome8) { + auto _len6 = *(cast(size_t*)(_retArea.ptr + (5*size_t.sizeof))); + auto _ptr6 = _len6 ? cast(char*)(*(cast(void**)(_retArea.ptr + (4*size_t.sizeof)))) : null; + auto _list7 = WitString(_ptr6[0.._len6]); + + _option8 = Option!(WitString).makeSome(_list7); + } else { + _option8 = Option!(WitString).makeNone; + } + auto _listSrcPtr12 = *(cast(void**)(_retArea.ptr + (6*size_t.sizeof))); + auto _listLen12 = *(cast(size_t*)(_retArea.ptr + (7*size_t.sizeof))); + auto _list12 = _listLen12 ? wit.common.mallocSlice!(WitString)(_listLen12) : []; + assert(!_listLen12 || _list12.ptr); + foreach (_elem9_idx, ref _elem9; _list12) { + const auto _base9 = _listSrcPtr12 + _elem9_idx * (2*size_t.sizeof); + auto _len10 = *(cast(size_t*)(_base9 + size_t.sizeof)); + auto _ptr10 = _len10 ? cast(char*)(*(cast(void**)(_base9 + 0))) : null; + auto _list11 = WitString(_ptr10[0.._len10]); + _elem9 = _list11; + } + if (_listLen12) wit.common.free(_listSrcPtr12); + auto _witList13 = WitList!(WitString)(_list12); + Option!(wit.pumpkin.plugin.advancement.imports.AdvancementDisplay) _option24 = void; + bool _isSome24 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (8*size_t.sizeof))))) != 0; + if (_isSome24) { + auto _handle16 = wit.pumpkin.plugin.advancement.imports.TextComponent(*(cast(uint*)(_retArea.ptr + (9*size_t.sizeof)))); + auto _handle17 = wit.pumpkin.plugin.advancement.imports.TextComponent(*(cast(uint*)(_retArea.ptr + (4+9*size_t.sizeof)))); + Option!(WitString) _option22 = void; + bool _isSome22 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (8+10*size_t.sizeof))))) != 0; + if (_isSome22) { + auto _len20 = *(cast(size_t*)(_retArea.ptr + (8+12*size_t.sizeof))); + auto _ptr20 = _len20 ? cast(char*)(*(cast(void**)(_retArea.ptr + (8+11*size_t.sizeof)))) : null; + auto _list21 = WitString(_ptr20[0.._len20]); + + _option22 = Option!(WitString).makeSome(_list21); + } else { + _option22 = Option!(WitString).makeNone; + } + wit.pumpkin.plugin.advancement.imports.AdvancementDisplay _record23 = { + title: _handle16, + description: _handle17, + frame: cast(wit.pumpkin.plugin.advancement.imports.FrameType)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (8+9*size_t.sizeof))))), + showToast: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (9+9*size_t.sizeof))))) != 0, + hidden: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (10+9*size_t.sizeof))))) != 0, + announceToChat: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (11+9*size_t.sizeof))))) != 0, + background: _option22, + x: *(cast(float*)(_retArea.ptr + (8+13*size_t.sizeof))), + y: *(cast(float*)(_retArea.ptr + (12+13*size_t.sizeof))), + }; + + _option24 = Option!(wit.pumpkin.plugin.advancement.imports.AdvancementDisplay).makeSome(_record23); + } else { + _option24 = Option!(wit.pumpkin.plugin.advancement.imports.AdvancementDisplay).makeNone; + } + wit.pumpkin.plugin.advancement.imports.AdvancementInfo _record25 = { + id: _list3, + parentId: _option8, + criteria: _witList13, + display: _option24, + }; + + _option26 = Option!(AdvancementInfo).makeSome(_record25); + } else { + _option26 = Option!(AdvancementInfo).makeNone; + } + auto _flush27 = _option26; + return _flush27; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-advancement") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_advancement") + static private extern(C) void __import_getAdvancement(uint, void*, size_t, void*) nothrow; + + /++ + Returns a list of all registered advancement IDs on the server. + +/ + WitList!(WitString) getAllAdvancementIds() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getAllAdvancementIds(this.__handle, _retArea.ptr); + auto _listSrcPtr3 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen3 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list3 = _listLen3 ? wit.common.mallocSlice!(WitString)(_listLen3) : []; + assert(!_listLen3 || _list3.ptr); + foreach (_elem0_idx, ref _elem0; _list3) { + const auto _base0 = _listSrcPtr3 + _elem0_idx * (2*size_t.sizeof); + auto _len1 = *(cast(size_t*)(_base0 + size_t.sizeof)); + auto _ptr1 = _len1 ? cast(char*)(*(cast(void**)(_base0 + 0))) : null; + auto _list2 = WitString(_ptr1[0.._len1]); + _elem0 = _list2; + } + if (_listLen3) wit.common.free(_listSrcPtr3); + auto _witList4 = WitList!(WitString)(_list3); + auto _flush5 = _witList4; + return _flush5; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-all-advancement-ids") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_all_advancement_ids") + static private extern(C) void __import_getAllAdvancementIds(uint, void*) nothrow; + + /++ + Returns the global enchantment manager for registering and querying custom enchantments. + +/ + EnchantmentManager getEnchantmentManager() @trusted nothrow { + auto _ret = __import_getEnchantmentManager(this.__handle); + auto _handle0 = EnchantmentManager(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-enchantment-manager") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_enchantment_manager") + static private extern(C) uint __import_getEnchantmentManager(uint) nothrow; + + /++ + Returns information about an enchantment by its ID (vanilla or custom). + +/ + Option!(CustomEnchantment) getEnchantment(in WitString id) @trusted nothrow { + align(size_t.sizeof) void[(8+11*size_t.sizeof)] _retArea = void; + __import_getEnchantment(this.__handle, cast(void*)(id.ptr), id.length, _retArea.ptr); + Option!(CustomEnchantment) _option16 = void; + bool _isSome16 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome16) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + auto _handle4 = wit.pumpkin.plugin.enchantments.imports.TextComponent(*(cast(uint*)(_retArea.ptr + (3*size_t.sizeof)))); + auto _len5 = *(cast(size_t*)(_retArea.ptr + (8+5*size_t.sizeof))); + auto _ptr5 = _len5 ? cast(char*)(*(cast(void**)(_retArea.ptr + (8+4*size_t.sizeof)))) : null; + auto _list6 = WitString(_ptr5[0.._len5]); + auto _listSrcPtr8 = *(cast(void**)(_retArea.ptr + (8+7*size_t.sizeof))); + auto _listLen8 = *(cast(size_t*)(_retArea.ptr + (8+8*size_t.sizeof))); + auto _list8 = _listLen8 ? wit.common.mallocSlice!(wit.pumpkin.plugin.enchantments.imports.AttributeModifierSlot)(_listLen8) : []; + assert(!_listLen8 || _list8.ptr); + foreach (_elem7_idx, ref _elem7; _list8) { + const auto _base7 = _listSrcPtr8 + _elem7_idx * 1; + _elem7 = cast(wit.pumpkin.plugin.enchantments.imports.AttributeModifierSlot)(cast(uint)(*(cast(ubyte*)(_base7 + 0)))); + } + if (_listLen8) wit.common.free(_listSrcPtr8); + auto _witList9 = WitList!(wit.pumpkin.plugin.enchantments.imports.AttributeModifierSlot)(_list8); + auto _listSrcPtr13 = *(cast(void**)(_retArea.ptr + (8+9*size_t.sizeof))); + auto _listLen13 = *(cast(size_t*)(_retArea.ptr + (8+10*size_t.sizeof))); + auto _list13 = _listLen13 ? wit.common.mallocSlice!(WitString)(_listLen13) : []; + assert(!_listLen13 || _list13.ptr); + foreach (_elem10_idx, ref _elem10; _list13) { + const auto _base10 = _listSrcPtr13 + _elem10_idx * (2*size_t.sizeof); + auto _len11 = *(cast(size_t*)(_base10 + size_t.sizeof)); + auto _ptr11 = _len11 ? cast(char*)(*(cast(void**)(_base10 + 0))) : null; + auto _list12 = WitString(_ptr11[0.._len11]); + _elem10 = _list12; + } + if (_listLen13) wit.common.free(_listSrcPtr13); + auto _witList14 = WitList!(WitString)(_list13); + wit.pumpkin.plugin.enchantments.imports.CustomEnchantment _record15 = { + id: _list3, + description: _handle4, + maxLevel: *(cast(uint*)(_retArea.ptr + (4+3*size_t.sizeof))), + anvilCost: *(cast(uint*)(_retArea.ptr + (8+3*size_t.sizeof))), + supportedItems: _list6, + weight: *(cast(uint*)(_retArea.ptr + (8+6*size_t.sizeof))), + slots: _witList9, + exclusiveSet: _witList14, + }; + + _option16 = Option!(CustomEnchantment).makeSome(_record15); + } else { + _option16 = Option!(CustomEnchantment).makeNone; + } + auto _flush17 = _option16; + return _flush17; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-enchantment") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_enchantment") + static private extern(C) void __import_getEnchantment(uint, void*, size_t, void*) nothrow; + + /++ + Returns a list of all registered enchantment IDs (custom and vanilla) on the server. + +/ + WitList!(WitString) getAllEnchantmentIds() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getAllEnchantmentIds(this.__handle, _retArea.ptr); + auto _listSrcPtr3 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen3 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list3 = _listLen3 ? wit.common.mallocSlice!(WitString)(_listLen3) : []; + assert(!_listLen3 || _list3.ptr); + foreach (_elem0_idx, ref _elem0; _list3) { + const auto _base0 = _listSrcPtr3 + _elem0_idx * (2*size_t.sizeof); + auto _len1 = *(cast(size_t*)(_base0 + size_t.sizeof)); + auto _ptr1 = _len1 ? cast(char*)(*(cast(void**)(_base0 + 0))) : null; + auto _list2 = WitString(_ptr1[0.._len1]); + _elem0 = _list2; + } + if (_listLen3) wit.common.free(_listSrcPtr3); + auto _witList4 = WitList!(WitString)(_list3); + auto _flush5 = _witList4; + return _flush5; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-all-enchantment-ids") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_all_enchantment_ids") + static private extern(C) void __import_getAllEnchantmentIds(uint, void*) nothrow; + + /++ + Returns the global datapack manager for inspecting, enabling, disabling, and reloading datapacks. + +/ + DatapackManager getDatapackManager() @trusted nothrow { + auto _ret = __import_getDatapackManager(this.__handle); + auto _handle0 = DatapackManager(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.get-datapack-manager") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.get_datapack_manager") + static private extern(C) uint __import_getDatapackManager(uint) nothrow; + + /++ + Broadcasts custom server links to all connected players (displayed in the client Esc pause menu in 1.21+). + +/ + void setServerLinks(in WitList!(ServerLink) links) @trusted nothrow { + wit.common.DeallocateBuffer deallocate; + auto _listSrc6 = links; + auto _list6 = _listSrc6.length ? wit.common.malloc(_listSrc6.length * ((8+2*size_t.sizeof))) : null; + assert(!_listSrc6.length || _list6); + if (_listSrc6.length) deallocate ~= _list6; + foreach (_elem0_idx, ref _elem0; _listSrc6) { + auto _base0 = _list6 + _elem0_idx * ((8+2*size_t.sizeof)); + alias _Tag5 = wit.pumpkin.plugin.player.imports.ServerLinkLabel.Tag; + final switch (_elem0.label.tag) { + case _Tag5.known: { + const ref wit.pumpkin.plugin.player.imports.KnownServerLink _payload2 = _elem0.label.getKnown(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(0); + *cast(ubyte*)(_base0 + 4) = cast(ubyte)(cast(uint)(_payload2)); + break; + } + case _Tag5.custom: { + const ref wit.pumpkin.plugin.player.imports.TextComponent _payload4 = _elem0.label.getCustom(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(1); + *cast(uint*)(_base0 + 4) = cast(uint)(_payload4.__handle); + break; + } + } + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_elem0.url.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_elem0.url.ptr)); + + } + __import_setServerLinks(this.__handle, _list6, links.length); + deallocate.purge(); + } + /// ditto + @wasmImport!("pumpkin:plugin/server@0.1.0", "[method]server.set-server-links") + pragma(mangle, "__wit_import_pumpkin:plugin__server@0.1.0__:method:server.set_server_links") + static private extern(C) void __import_setServerLinks(uint, void*, size_t) nothrow; + } +} diff --git a/src/wit/pumpkin/plugin/sounds/common.d b/src/wit/pumpkin/plugin/sounds/common.d new file mode 100644 index 0000000..cc27eb5 --- /dev/null +++ b/src/wit/pumpkin/plugin/sounds/common.d @@ -0,0 +1,9914 @@ +/++ + ++/ +module wit.pumpkin.plugin.sounds.common; + + +import wit.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +enum SoundCategory : ubyte { + /++ + + +/ + master, + + /++ + + +/ + music, + + /++ + + +/ + records, + + /++ + + +/ + weather, + + /++ + + +/ + blocks, + + /++ + + +/ + hostile, + + /++ + + +/ + neutral, + + /++ + + +/ + players, + + /++ + + +/ + ambient, + + /++ + + +/ + voice, + + /++ + + +/ + ui, +} +/++ + ++/ +enum Sound : ushort { + /++ + + +/ + entityAllayAmbientWithItem, + + /++ + + +/ + entityAllayAmbientWithoutItem, + + /++ + + +/ + entityAllayDeath, + + /++ + + +/ + entityAllayHurt, + + /++ + + +/ + entityAllayItemGiven, + + /++ + + +/ + entityAllayItemTaken, + + /++ + + +/ + entityAllayItemThrown, + + /++ + + +/ + ambientCave, + + /++ + + +/ + ambientBasaltDeltasAdditions, + + /++ + + +/ + ambientBasaltDeltasLoop, + + /++ + + +/ + ambientBasaltDeltasMood, + + /++ + + +/ + ambientCrimsonForestAdditions, + + /++ + + +/ + ambientCrimsonForestLoop, + + /++ + + +/ + ambientCrimsonForestMood, + + /++ + + +/ + ambientNetherWastesAdditions, + + /++ + + +/ + ambientNetherWastesLoop, + + /++ + + +/ + ambientNetherWastesMood, + + /++ + + +/ + ambientSoulSandValleyAdditions, + + /++ + + +/ + ambientSoulSandValleyLoop, + + /++ + + +/ + ambientSoulSandValleyMood, + + /++ + + +/ + ambientWarpedForestAdditions, + + /++ + + +/ + ambientWarpedForestLoop, + + /++ + + +/ + ambientWarpedForestMood, + + /++ + + +/ + ambientUnderwaterEnter, + + /++ + + +/ + ambientUnderwaterExit, + + /++ + + +/ + ambientUnderwaterLoop, + + /++ + + +/ + ambientUnderwaterLoopAdditions, + + /++ + + +/ + ambientUnderwaterLoopAdditionsRare, + + /++ + + +/ + ambientUnderwaterLoopAdditionsUltraRare, + + /++ + + +/ + blockAmethystBlockBreak, + + /++ + + +/ + blockAmethystBlockChime, + + /++ + + +/ + blockAmethystBlockFall, + + /++ + + +/ + blockAmethystBlockHit, + + /++ + + +/ + blockAmethystBlockPlace, + + /++ + + +/ + blockAmethystBlockResonate, + + /++ + + +/ + blockAmethystBlockStep, + + /++ + + +/ + blockAmethystClusterBreak, + + /++ + + +/ + blockAmethystClusterFall, + + /++ + + +/ + blockAmethystClusterHit, + + /++ + + +/ + blockAmethystClusterPlace, + + /++ + + +/ + blockAmethystClusterStep, + + /++ + + +/ + blockAncientDebrisBreak, + + /++ + + +/ + blockAncientDebrisStep, + + /++ + + +/ + blockAncientDebrisPlace, + + /++ + + +/ + blockAncientDebrisHit, + + /++ + + +/ + blockAncientDebrisFall, + + /++ + + +/ + blockAnvilBreak, + + /++ + + +/ + blockAnvilDestroy, + + /++ + + +/ + blockAnvilFall, + + /++ + + +/ + blockAnvilHit, + + /++ + + +/ + blockAnvilLand, + + /++ + + +/ + blockAnvilPlace, + + /++ + + +/ + blockAnvilStep, + + /++ + + +/ + blockAnvilUse, + + /++ + + +/ + entityArmadilloEat, + + /++ + + +/ + entityArmadilloHurt, + + /++ + + +/ + entityArmadilloHurtReduced, + + /++ + + +/ + entityArmadilloAmbient, + + /++ + + +/ + entityArmadilloStep, + + /++ + + +/ + entityArmadilloDeath, + + /++ + + +/ + entityArmadilloRoll, + + /++ + + +/ + entityArmadilloLand, + + /++ + + +/ + entityArmadilloScuteDrop, + + /++ + + +/ + entityArmadilloUnrollFinish, + + /++ + + +/ + entityArmadilloPeek, + + /++ + + +/ + entityArmadilloUnrollStart, + + /++ + + +/ + entityArmadilloBrush, + + /++ + + +/ + itemArmorEquipChain, + + /++ + + +/ + itemArmorEquipDiamond, + + /++ + + +/ + itemArmorEquipElytra, + + /++ + + +/ + itemArmorEquipGeneric, + + /++ + + +/ + itemArmorEquipGold, + + /++ + + +/ + itemArmorEquipIron, + + /++ + + +/ + itemArmorEquipLeather, + + /++ + + +/ + itemArmorEquipCopper, + + /++ + + +/ + itemArmorEquipNetherite, + + /++ + + +/ + itemArmorEquipTurtle, + + /++ + + +/ + itemArmorEquipWolf, + + /++ + + +/ + itemArmorUnequipWolf, + + /++ + + +/ + itemArmorEquipNautilus, + + /++ + + +/ + itemArmorUnequipNautilus, + + /++ + + +/ + entityArmorStandBreak, + + /++ + + +/ + entityArmorStandFall, + + /++ + + +/ + entityArmorStandHit, + + /++ + + +/ + entityArmorStandPlace, + + /++ + + +/ + entityArrowHit, + + /++ + + +/ + entityArrowHitPlayer, + + /++ + + +/ + entityArrowShoot, + + /++ + + +/ + itemAxeStrip, + + /++ + + +/ + itemAxeScrape, + + /++ + + +/ + itemAxeWaxOff, + + /++ + + +/ + entityAxolotlAttack, + + /++ + + +/ + entityAxolotlDeath, + + /++ + + +/ + entityAxolotlHurt, + + /++ + + +/ + entityAxolotlIdleAir, + + /++ + + +/ + entityAxolotlIdleWater, + + /++ + + +/ + entityAxolotlSplash, + + /++ + + +/ + entityAxolotlSwim, + + /++ + + +/ + blockAzaleaBreak, + + /++ + + +/ + blockAzaleaFall, + + /++ + + +/ + blockAzaleaHit, + + /++ + + +/ + blockAzaleaPlace, + + /++ + + +/ + blockAzaleaStep, + + /++ + + +/ + blockAzaleaLeavesBreak, + + /++ + + +/ + blockAzaleaLeavesFall, + + /++ + + +/ + blockAzaleaLeavesHit, + + /++ + + +/ + blockAzaleaLeavesPlace, + + /++ + + +/ + blockAzaleaLeavesStep, + + /++ + + +/ + entityBabyNautilusAmbient, + + /++ + + +/ + entityBabyNautilusAmbientLand, + + /++ + + +/ + entityBabyNautilusDeath, + + /++ + + +/ + entityBabyNautilusDeathLand, + + /++ + + +/ + entityBabyNautilusEat, + + /++ + + +/ + entityBabyNautilusHurt, + + /++ + + +/ + entityBabyNautilusHurtLand, + + /++ + + +/ + entityNautilusRiding, + + /++ + + +/ + entityBabyNautilusSwim, + + /++ + + +/ + blockBambooBreak, + + /++ + + +/ + blockBambooFall, + + /++ + + +/ + blockBambooHit, + + /++ + + +/ + blockBambooPlace, + + /++ + + +/ + blockBambooStep, + + /++ + + +/ + blockBambooSaplingBreak, + + /++ + + +/ + blockBambooSaplingHit, + + /++ + + +/ + blockBambooSaplingPlace, + + /++ + + +/ + blockBambooWoodBreak, + + /++ + + +/ + blockBambooWoodFall, + + /++ + + +/ + blockBambooWoodHit, + + /++ + + +/ + blockBambooWoodPlace, + + /++ + + +/ + blockBambooWoodStep, + + /++ + + +/ + blockBambooWoodDoorClose, + + /++ + + +/ + blockBambooWoodDoorOpen, + + /++ + + +/ + blockBambooWoodTrapdoorClose, + + /++ + + +/ + blockBambooWoodTrapdoorOpen, + + /++ + + +/ + blockBambooWoodButtonClickOff, + + /++ + + +/ + blockBambooWoodButtonClickOn, + + /++ + + +/ + blockBambooWoodPressurePlateClickOff, + + /++ + + +/ + blockBambooWoodPressurePlateClickOn, + + /++ + + +/ + blockBambooWoodFenceGateClose, + + /++ + + +/ + blockBambooWoodFenceGateOpen, + + /++ + + +/ + blockBarrelClose, + + /++ + + +/ + blockBarrelOpen, + + /++ + + +/ + blockBasaltBreak, + + /++ + + +/ + blockBasaltStep, + + /++ + + +/ + blockBasaltPlace, + + /++ + + +/ + blockBasaltHit, + + /++ + + +/ + blockBasaltFall, + + /++ + + +/ + entityBatAmbient, + + /++ + + +/ + entityBatDeath, + + /++ + + +/ + entityBatHurt, + + /++ + + +/ + entityBatLoop, + + /++ + + +/ + entityBatTakeoff, + + /++ + + +/ + blockBeaconActivate, + + /++ + + +/ + blockBeaconAmbient, + + /++ + + +/ + blockBeaconDeactivate, + + /++ + + +/ + blockBeaconPowerSelect, + + /++ + + +/ + entityBeeDeath, + + /++ + + +/ + entityBeeHurt, + + /++ + + +/ + entityBeeLoopAggressive, + + /++ + + +/ + entityBeeLoop, + + /++ + + +/ + entityBeeSting, + + /++ + + +/ + entityBeePollinate, + + /++ + + +/ + blockBeehiveDrip, + + /++ + + +/ + blockBeehiveEnter, + + /++ + + +/ + blockBeehiveExit, + + /++ + + +/ + blockBeehiveShear, + + /++ + + +/ + blockBeehiveWork, + + /++ + + +/ + blockBellUse, + + /++ + + +/ + blockBellResonate, + + /++ + + +/ + blockBigDripleafBreak, + + /++ + + +/ + blockBigDripleafFall, + + /++ + + +/ + blockBigDripleafHit, + + /++ + + +/ + blockBigDripleafPlace, + + /++ + + +/ + blockBigDripleafStep, + + /++ + + +/ + entityBlazeAmbient, + + /++ + + +/ + entityBlazeBurn, + + /++ + + +/ + entityBlazeDeath, + + /++ + + +/ + entityBlazeHurt, + + /++ + + +/ + entityBlazeShoot, + + /++ + + +/ + entityBoatPaddleLand, + + /++ + + +/ + entityBoatPaddleWater, + + /++ + + +/ + entityBoggedAmbient, + + /++ + + +/ + entityBoggedDeath, + + /++ + + +/ + entityBoggedHurt, + + /++ + + +/ + entityBoggedShear, + + /++ + + +/ + entityBoggedStep, + + /++ + + +/ + blockBoneBlockBreak, + + /++ + + +/ + blockBoneBlockFall, + + /++ + + +/ + blockBoneBlockHit, + + /++ + + +/ + blockBoneBlockPlace, + + /++ + + +/ + blockBoneBlockStep, + + /++ + + +/ + itemBoneMealUse, + + /++ + + +/ + itemBookPageTurn, + + /++ + + +/ + itemBookPut, + + /++ + + +/ + blockBlastfurnaceFireCrackle, + + /++ + + +/ + itemBottleEmpty, + + /++ + + +/ + itemBottleFill, + + /++ + + +/ + itemBottleFillDragonbreath, + + /++ + + +/ + entityBreezeCharge, + + /++ + + +/ + entityBreezeDeflect, + + /++ + + +/ + entityBreezeInhale, + + /++ + + +/ + entityBreezeIdleGround, + + /++ + + +/ + entityBreezeIdleAir, + + /++ + + +/ + entityBreezeShoot, + + /++ + + +/ + entityBreezeJump, + + /++ + + +/ + entityBreezeLand, + + /++ + + +/ + entityBreezeSlide, + + /++ + + +/ + entityBreezeDeath, + + /++ + + +/ + entityBreezeHurt, + + /++ + + +/ + entityBreezeWhirl, + + /++ + + +/ + entityBreezeWindBurst, + + /++ + + +/ + blockBrewingStandBrew, + + /++ + + +/ + itemBrushBrushingGeneric, + + /++ + + +/ + itemBrushBrushingSand, + + /++ + + +/ + itemBrushBrushingGravel, + + /++ + + +/ + itemBrushBrushingSandComplete, + + /++ + + +/ + itemBrushBrushingGravelComplete, + + /++ + + +/ + blockBubbleColumnBubblePop, + + /++ + + +/ + blockBubbleColumnUpwardsAmbient, + + /++ + + +/ + blockBubbleColumnUpwardsInside, + + /++ + + +/ + blockBubbleColumnWhirlpoolAmbient, + + /++ + + +/ + blockBubbleColumnWhirlpoolInside, + + /++ + + +/ + uiHudBubblePop, + + /++ + + +/ + itemBucketEmpty, + + /++ + + +/ + itemBucketEmptyAxolotl, + + /++ + + +/ + itemBucketEmptyFish, + + /++ + + +/ + itemBucketEmptyLava, + + /++ + + +/ + itemBucketEmptyPowderSnow, + + /++ + + +/ + itemBucketEmptySulfurCube, + + /++ + + +/ + itemBucketEmptyTadpole, + + /++ + + +/ + itemBucketFill, + + /++ + + +/ + itemBucketFillAxolotl, + + /++ + + +/ + itemBucketFillFish, + + /++ + + +/ + itemBucketFillLava, + + /++ + + +/ + itemBucketFillPowderSnow, + + /++ + + +/ + itemBucketFillSulfurCube, + + /++ + + +/ + itemBucketFillTadpole, + + /++ + + +/ + itemBundleDropContents, + + /++ + + +/ + itemBundleInsert, + + /++ + + +/ + itemBundleInsertFail, + + /++ + + +/ + itemBundleRemoveOne, + + /++ + + +/ + blockCactusFlowerBreak, + + /++ + + +/ + blockCactusFlowerPlace, + + /++ + + +/ + blockCakeAddCandle, + + /++ + + +/ + blockCalciteBreak, + + /++ + + +/ + blockCalciteStep, + + /++ + + +/ + blockCalcitePlace, + + /++ + + +/ + blockCalciteHit, + + /++ + + +/ + blockCalciteFall, + + /++ + + +/ + entityCamelHuskAmbient, + + /++ + + +/ + entityCamelHuskDash, + + /++ + + +/ + entityCamelHuskDashReady, + + /++ + + +/ + entityCamelHuskDeath, + + /++ + + +/ + entityCamelHuskEat, + + /++ + + +/ + entityCamelHuskHurt, + + /++ + + +/ + entityCamelHuskSaddle, + + /++ + + +/ + entityCamelHuskSit, + + /++ + + +/ + entityCamelHuskStand, + + /++ + + +/ + entityCamelHuskStep, + + /++ + + +/ + entityCamelHuskStepSand, + + /++ + + +/ + entityCamelAmbient, + + /++ + + +/ + entityCamelDash, + + /++ + + +/ + entityCamelDashReady, + + /++ + + +/ + entityCamelDeath, + + /++ + + +/ + entityCamelEat, + + /++ + + +/ + entityCamelHurt, + + /++ + + +/ + entityCamelSaddle, + + /++ + + +/ + entityCamelSit, + + /++ + + +/ + entityCamelStand, + + /++ + + +/ + entityCamelStep, + + /++ + + +/ + entityCamelStepSand, + + /++ + + +/ + blockCampfireCrackle, + + /++ + + +/ + blockCandleAmbient, + + /++ + + +/ + blockCandleBreak, + + /++ + + +/ + blockCandleExtinguish, + + /++ + + +/ + blockCandleFall, + + /++ + + +/ + blockCandleHit, + + /++ + + +/ + blockCandlePlace, + + /++ + + +/ + blockCandleStep, + + /++ + + +/ + entityBabyCatAmbient, + + /++ + + +/ + entityBabyCatStrayAmbient, + + /++ + + +/ + entityBabyCatDeath, + + /++ + + +/ + entityBabyCatEat, + + /++ + + +/ + entityBabyCatHiss, + + /++ + + +/ + entityBabyCatBegForFood, + + /++ + + +/ + entityBabyCatHurt, + + /++ + + +/ + entityBabyCatPurr, + + /++ + + +/ + entityBabyCatPurreow, + + /++ + + +/ + entityCatAmbient, + + /++ + + +/ + entityCatStrayAmbient, + + /++ + + +/ + entityCatHiss, + + /++ + + +/ + entityCatHurt, + + /++ + + +/ + entityCatDeath, + + /++ + + +/ + entityCatEat, + + /++ + + +/ + entityCatBegForFood, + + /++ + + +/ + entityCatPurr, + + /++ + + +/ + entityCatPurreow, + + /++ + + +/ + entityCatRoyalAmbient, + + /++ + + +/ + entityCatRoyalStrayAmbient, + + /++ + + +/ + entityCatRoyalHiss, + + /++ + + +/ + entityCatRoyalHurt, + + /++ + + +/ + entityCatRoyalDeath, + + /++ + + +/ + entityCatRoyalEat, + + /++ + + +/ + entityCatRoyalBegForFood, + + /++ + + +/ + entityCatRoyalPurr, + + /++ + + +/ + entityCatRoyalPurreow, + + /++ + + +/ + blockCaveVinesBreak, + + /++ + + +/ + blockCaveVinesFall, + + /++ + + +/ + blockCaveVinesHit, + + /++ + + +/ + blockCaveVinesPlace, + + /++ + + +/ + blockCaveVinesStep, + + /++ + + +/ + blockCaveVinesPickBerries, + + /++ + + +/ + blockChainBreak, + + /++ + + +/ + blockChainFall, + + /++ + + +/ + blockChainHit, + + /++ + + +/ + blockChainPlace, + + /++ + + +/ + blockChainStep, + + /++ + + +/ + blockCherryWoodBreak, + + /++ + + +/ + blockCherryWoodFall, + + /++ + + +/ + blockCherryWoodHit, + + /++ + + +/ + blockCherryWoodPlace, + + /++ + + +/ + blockCherryWoodStep, + + /++ + + +/ + blockCherrySaplingBreak, + + /++ + + +/ + blockCherrySaplingFall, + + /++ + + +/ + blockCherrySaplingHit, + + /++ + + +/ + blockCherrySaplingPlace, + + /++ + + +/ + blockCherrySaplingStep, + + /++ + + +/ + blockCherryLeavesBreak, + + /++ + + +/ + blockCherryLeavesFall, + + /++ + + +/ + blockCherryLeavesHit, + + /++ + + +/ + blockCherryLeavesPlace, + + /++ + + +/ + blockCherryLeavesStep, + + /++ + + +/ + blockCherryWoodHangingSignStep, + + /++ + + +/ + blockCherryWoodHangingSignBreak, + + /++ + + +/ + blockCherryWoodHangingSignFall, + + /++ + + +/ + blockCherryWoodHangingSignHit, + + /++ + + +/ + blockCherryWoodHangingSignPlace, + + /++ + + +/ + blockCherryWoodDoorClose, + + /++ + + +/ + blockCherryWoodDoorOpen, + + /++ + + +/ + blockCherryWoodTrapdoorClose, + + /++ + + +/ + blockCherryWoodTrapdoorOpen, + + /++ + + +/ + blockCherryWoodButtonClickOff, + + /++ + + +/ + blockCherryWoodButtonClickOn, + + /++ + + +/ + blockCherryWoodPressurePlateClickOff, + + /++ + + +/ + blockCherryWoodPressurePlateClickOn, + + /++ + + +/ + blockCherryWoodFenceGateClose, + + /++ + + +/ + blockCherryWoodFenceGateOpen, + + /++ + + +/ + blockChestClose, + + /++ + + +/ + blockChestLocked, + + /++ + + +/ + blockChestOpen, + + /++ + + +/ + entityBabyChickenAmbient, + + /++ + + +/ + entityBabyChickenDeath, + + /++ + + +/ + entityChickenEgg, + + /++ + + +/ + entityBabyChickenHurt, + + /++ + + +/ + entityChickenStep, + + /++ + + +/ + entityBabyChickenStep, + + /++ + + +/ + entityChickenAmbient, + + /++ + + +/ + entityChickenHurt, + + /++ + + +/ + entityChickenDeath, + + /++ + + +/ + entityChickenPickyAmbient, + + /++ + + +/ + entityChickenPickyHurt, + + /++ + + +/ + entityChickenPickyDeath, + + /++ + + +/ + blockChiseledBookshelfBreak, + + /++ + + +/ + blockChiseledBookshelfFall, + + /++ + + +/ + blockChiseledBookshelfHit, + + /++ + + +/ + blockChiseledBookshelfInsert, + + /++ + + +/ + blockChiseledBookshelfInsertEnchanted, + + /++ + + +/ + blockChiseledBookshelfStep, + + /++ + + +/ + blockChiseledBookshelfPickup, + + /++ + + +/ + blockChiseledBookshelfPickupEnchanted, + + /++ + + +/ + blockChiseledBookshelfPlace, + + /++ + + +/ + blockChorusFlowerDeath, + + /++ + + +/ + blockChorusFlowerGrow, + + /++ + + +/ + itemChorusFruitTeleport, + + /++ + + +/ + blockCobwebBreak, + + /++ + + +/ + blockCobwebStep, + + /++ + + +/ + blockCobwebPlace, + + /++ + + +/ + blockCobwebHit, + + /++ + + +/ + blockCobwebFall, + + /++ + + +/ + entityCodAmbient, + + /++ + + +/ + entityCodDeath, + + /++ + + +/ + entityCodFlop, + + /++ + + +/ + entityCodHurt, + + /++ + + +/ + blockComparatorClick, + + /++ + + +/ + blockComposterEmpty, + + /++ + + +/ + blockComposterFill, + + /++ + + +/ + blockComposterFillSuccess, + + /++ + + +/ + blockComposterReady, + + /++ + + +/ + blockConduitActivate, + + /++ + + +/ + blockConduitAmbient, + + /++ + + +/ + blockConduitAmbientShort, + + /++ + + +/ + blockConduitAttackTarget, + + /++ + + +/ + blockConduitDeactivate, + + /++ + + +/ + blockCopperBulbBreak, + + /++ + + +/ + blockCopperBulbStep, + + /++ + + +/ + blockCopperBulbPlace, + + /++ + + +/ + blockCopperBulbHit, + + /++ + + +/ + blockCopperBulbFall, + + /++ + + +/ + blockCopperBulbTurnOn, + + /++ + + +/ + blockCopperBulbTurnOff, + + /++ + + +/ + blockCopperBreak, + + /++ + + +/ + blockCopperStep, + + /++ + + +/ + blockCopperPlace, + + /++ + + +/ + blockCopperHit, + + /++ + + +/ + blockCopperFall, + + /++ + + +/ + blockCopperChestClose, + + /++ + + +/ + blockCopperChestOpen, + + /++ + + +/ + blockCopperChestWeatheredClose, + + /++ + + +/ + blockCopperChestWeatheredOpen, + + /++ + + +/ + blockCopperChestOxidizedClose, + + /++ + + +/ + blockCopperChestOxidizedOpen, + + /++ + + +/ + blockCopperDoorClose, + + /++ + + +/ + blockCopperDoorOpen, + + /++ + + +/ + entityCopperGolemStep, + + /++ + + +/ + entityCopperGolemHurt, + + /++ + + +/ + entityCopperGolemDeath, + + /++ + + +/ + entityCopperGolemWeatheredStep, + + /++ + + +/ + entityCopperGolemWeatheredHurt, + + /++ + + +/ + entityCopperGolemWeatheredDeath, + + /++ + + +/ + entityCopperGolemOxidizedStep, + + /++ + + +/ + entityCopperGolemOxidizedHurt, + + /++ + + +/ + entityCopperGolemOxidizedDeath, + + /++ + + +/ + entityCopperGolemSpin, + + /++ + + +/ + entityCopperGolemWeatheredSpin, + + /++ + + +/ + entityCopperGolemOxidizedSpin, + + /++ + + +/ + entityCopperGolemNoItemGet, + + /++ + + +/ + entityCopperGolemNoItemNoGet, + + /++ + + +/ + entityCopperGolemItemDrop, + + /++ + + +/ + entityCopperGolemItemNoDrop, + + /++ + + +/ + entityCopperGolemBecomeStatue, + + /++ + + +/ + blockCopperGolemStatueBreak, + + /++ + + +/ + blockCopperGolemStatuePlace, + + /++ + + +/ + blockCopperGolemStatueHit, + + /++ + + +/ + blockCopperGolemStatueStep, + + /++ + + +/ + blockCopperGolemStatueFall, + + /++ + + +/ + entityCopperGolemSpawn, + + /++ + + +/ + entityCopperGolemShear, + + /++ + + +/ + blockCopperGrateBreak, + + /++ + + +/ + blockCopperGrateStep, + + /++ + + +/ + blockCopperGratePlace, + + /++ + + +/ + blockCopperGrateHit, + + /++ + + +/ + blockCopperGrateFall, + + /++ + + +/ + blockCopperTrapdoorClose, + + /++ + + +/ + blockCopperTrapdoorOpen, + + /++ + + +/ + blockCoralBlockBreak, + + /++ + + +/ + blockCoralBlockFall, + + /++ + + +/ + blockCoralBlockHit, + + /++ + + +/ + blockCoralBlockPlace, + + /++ + + +/ + blockCoralBlockStep, + + /++ + + +/ + entityCowMilk, + + /++ + + +/ + entityCowAmbient, + + /++ + + +/ + entityCowHurt, + + /++ + + +/ + entityCowDeath, + + /++ + + +/ + entityCowStep, + + /++ + + +/ + entityCowMoodyAmbient, + + /++ + + +/ + entityCowMoodyHurt, + + /++ + + +/ + entityCowMoodyDeath, + + /++ + + +/ + entityCowMoodyStep, + + /++ + + +/ + blockCrafterCraft, + + /++ + + +/ + blockCrafterFail, + + /++ + + +/ + entityCreakingAmbient, + + /++ + + +/ + entityCreakingActivate, + + /++ + + +/ + entityCreakingDeactivate, + + /++ + + +/ + entityCreakingAttack, + + /++ + + +/ + entityCreakingDeath, + + /++ + + +/ + entityCreakingStep, + + /++ + + +/ + entityCreakingFreeze, + + /++ + + +/ + entityCreakingUnfreeze, + + /++ + + +/ + entityCreakingSpawn, + + /++ + + +/ + entityCreakingSway, + + /++ + + +/ + entityCreakingTwitch, + + /++ + + +/ + blockCreakingHeartBreak, + + /++ + + +/ + blockCreakingHeartFall, + + /++ + + +/ + blockCreakingHeartHit, + + /++ + + +/ + blockCreakingHeartHurt, + + /++ + + +/ + blockCreakingHeartPlace, + + /++ + + +/ + blockCreakingHeartStep, + + /++ + + +/ + blockCreakingHeartIdle, + + /++ + + +/ + blockCreakingHeartSpawn, + + /++ + + +/ + entityCreeperDeath, + + /++ + + +/ + entityCreeperHurt, + + /++ + + +/ + entityCreeperPrimed, + + /++ + + +/ + blockCropBreak, + + /++ + + +/ + itemCropPlant, + + /++ + + +/ + itemCrossbowHit, + + /++ + + +/ + itemCrossbowLoadingEnd, + + /++ + + +/ + itemCrossbowLoadingMiddle, + + /++ + + +/ + itemCrossbowLoadingStart, + + /++ + + +/ + itemCrossbowQuickCharge1, + + /++ + + +/ + itemCrossbowQuickCharge2, + + /++ + + +/ + itemCrossbowQuickCharge3, + + /++ + + +/ + itemCrossbowShoot, + + /++ + + +/ + blockDeadbushIdle, + + /++ + + +/ + blockDecoratedPotBreak, + + /++ + + +/ + blockDecoratedPotFall, + + /++ + + +/ + blockDecoratedPotHit, + + /++ + + +/ + blockDecoratedPotInsert, + + /++ + + +/ + blockDecoratedPotInsertFail, + + /++ + + +/ + blockDecoratedPotStep, + + /++ + + +/ + blockDecoratedPotPlace, + + /++ + + +/ + blockDecoratedPotShatter, + + /++ + + +/ + blockDeepslateBricksBreak, + + /++ + + +/ + blockDeepslateBricksFall, + + /++ + + +/ + blockDeepslateBricksHit, + + /++ + + +/ + blockDeepslateBricksPlace, + + /++ + + +/ + blockDeepslateBricksStep, + + /++ + + +/ + blockDeepslateBreak, + + /++ + + +/ + blockDeepslateFall, + + /++ + + +/ + blockDeepslateHit, + + /++ + + +/ + blockDeepslatePlace, + + /++ + + +/ + blockDeepslateStep, + + /++ + + +/ + blockDeepslateTilesBreak, + + /++ + + +/ + blockDeepslateTilesFall, + + /++ + + +/ + blockDeepslateTilesHit, + + /++ + + +/ + blockDeepslateTilesPlace, + + /++ + + +/ + blockDeepslateTilesStep, + + /++ + + +/ + blockDispenserDispense, + + /++ + + +/ + blockDispenserFail, + + /++ + + +/ + blockDispenserLaunch, + + /++ + + +/ + entityDolphinAmbient, + + /++ + + +/ + entityDolphinAmbientWater, + + /++ + + +/ + entityDolphinAttack, + + /++ + + +/ + entityDolphinDeath, + + /++ + + +/ + entityDolphinEat, + + /++ + + +/ + entityDolphinHurt, + + /++ + + +/ + entityDolphinJump, + + /++ + + +/ + entityDolphinPlay, + + /++ + + +/ + entityDolphinSplash, + + /++ + + +/ + entityDolphinSwim, + + /++ + + +/ + entityDonkeyAmbient, + + /++ + + +/ + entityDonkeyAngry, + + /++ + + +/ + entityDonkeyChest, + + /++ + + +/ + entityDonkeyDeath, + + /++ + + +/ + entityDonkeyEat, + + /++ + + +/ + entityDonkeyHurt, + + /++ + + +/ + entityDonkeyJump, + + /++ + + +/ + blockDriedGhastBreak, + + /++ + + +/ + blockDriedGhastStep, + + /++ + + +/ + blockDriedGhastFall, + + /++ + + +/ + blockDriedGhastAmbient, + + /++ + + +/ + blockDriedGhastAmbientWater, + + /++ + + +/ + blockDriedGhastPlace, + + /++ + + +/ + blockDriedGhastPlaceInWater, + + /++ + + +/ + blockDriedGhastTransition, + + /++ + + +/ + blockDripstoneBlockBreak, + + /++ + + +/ + blockDripstoneBlockStep, + + /++ + + +/ + blockDripstoneBlockPlace, + + /++ + + +/ + blockDripstoneBlockHit, + + /++ + + +/ + blockDripstoneBlockFall, + + /++ + + +/ + blockDryGrassAmbient, + + /++ + + +/ + blockPointedDripstoneBreak, + + /++ + + +/ + blockPointedDripstoneStep, + + /++ + + +/ + blockPointedDripstonePlace, + + /++ + + +/ + blockPointedDripstoneHit, + + /++ + + +/ + blockPointedDripstoneFall, + + /++ + + +/ + blockPointedDripstoneLand, + + /++ + + +/ + blockPointedDripstoneDripLava, + + /++ + + +/ + blockPointedDripstoneDripWater, + + /++ + + +/ + blockPointedDripstoneDripLavaIntoCauldron, + + /++ + + +/ + blockPointedDripstoneDripWaterIntoCauldron, + + /++ + + +/ + blockBigDripleafTiltDown, + + /++ + + +/ + blockBigDripleafTiltUp, + + /++ + + +/ + entityDrownedAmbient, + + /++ + + +/ + entityDrownedAmbientWater, + + /++ + + +/ + entityDrownedDeath, + + /++ + + +/ + entityDrownedDeathWater, + + /++ + + +/ + entityDrownedHurt, + + /++ + + +/ + entityDrownedHurtWater, + + /++ + + +/ + entityDrownedShoot, + + /++ + + +/ + entityDrownedStep, + + /++ + + +/ + entityDrownedSwim, + + /++ + + +/ + itemDyeUse, + + /++ + + +/ + entityEggThrow, + + /++ + + +/ + entityElderGuardianAmbient, + + /++ + + +/ + entityElderGuardianAmbientLand, + + /++ + + +/ + entityElderGuardianCurse, + + /++ + + +/ + entityElderGuardianDeath, + + /++ + + +/ + entityElderGuardianDeathLand, + + /++ + + +/ + entityElderGuardianFlop, + + /++ + + +/ + entityElderGuardianHurt, + + /++ + + +/ + entityElderGuardianHurtLand, + + /++ + + +/ + itemElytraFlying, + + /++ + + +/ + blockEnchantmentTableUse, + + /++ + + +/ + blockEnderChestClose, + + /++ + + +/ + blockEnderChestOpen, + + /++ + + +/ + entityEnderDragonAmbient, + + /++ + + +/ + entityEnderDragonDeath, + + /++ + + +/ + entityDragonFireballExplode, + + /++ + + +/ + entityEnderDragonFlap, + + /++ + + +/ + entityEnderDragonGrowl, + + /++ + + +/ + entityEnderDragonHurt, + + /++ + + +/ + entityEnderDragonShoot, + + /++ + + +/ + entityEnderEyeDeath, + + /++ + + +/ + entityEnderEyeLaunch, + + /++ + + +/ + entityEndermanAmbient, + + /++ + + +/ + entityEndermanDeath, + + /++ + + +/ + entityEndermanHurt, + + /++ + + +/ + entityEndermanScream, + + /++ + + +/ + entityEndermanStare, + + /++ + + +/ + entityEndermanTeleport, + + /++ + + +/ + entityEndermiteAmbient, + + /++ + + +/ + entityEndermiteDeath, + + /++ + + +/ + entityEndermiteHurt, + + /++ + + +/ + entityEndermiteStep, + + /++ + + +/ + entityEnderPearlThrow, + + /++ + + +/ + blockEndGatewaySpawn, + + /++ + + +/ + blockEndPortalFrameFill, + + /++ + + +/ + blockEndPortalSpawn, + + /++ + + +/ + entityEvokerAmbient, + + /++ + + +/ + entityEvokerCastSpell, + + /++ + + +/ + entityEvokerCelebrate, + + /++ + + +/ + entityEvokerDeath, + + /++ + + +/ + entityEvokerFangsAttack, + + /++ + + +/ + entityEvokerHurt, + + /++ + + +/ + entityEvokerPrepareAttack, + + /++ + + +/ + entityEvokerPrepareSummon, + + /++ + + +/ + entityEvokerPrepareWololo, + + /++ + + +/ + entityExperienceBottleThrow, + + /++ + + +/ + entityExperienceOrbPickup, + + /++ + + +/ + blockEyeblossomOpenLong, + + /++ + + +/ + blockEyeblossomOpen, + + /++ + + +/ + blockEyeblossomCloseLong, + + /++ + + +/ + blockEyeblossomClose, + + /++ + + +/ + blockEyeblossomIdle, + + /++ + + +/ + blockFenceGateClose, + + /++ + + +/ + blockFenceGateOpen, + + /++ + + +/ + itemFirechargeUse, + + /++ + + +/ + blockFireflyBushIdle, + + /++ + + +/ + entityFireworkRocketBlast, + + /++ + + +/ + entityFireworkRocketBlastFar, + + /++ + + +/ + entityFireworkRocketLargeBlast, + + /++ + + +/ + entityFireworkRocketLargeBlastFar, + + /++ + + +/ + entityFireworkRocketLaunch, + + /++ + + +/ + entityFireworkRocketShoot, + + /++ + + +/ + entityFireworkRocketTwinkle, + + /++ + + +/ + entityFireworkRocketTwinkleFar, + + /++ + + +/ + blockFireAmbient, + + /++ + + +/ + blockFireExtinguish, + + /++ + + +/ + entityFishSwim, + + /++ + + +/ + entityFishingBobberRetrieve, + + /++ + + +/ + entityFishingBobberSplash, + + /++ + + +/ + entityFishingBobberThrow, + + /++ + + +/ + itemFlintandsteelUse, + + /++ + + +/ + blockFloweringAzaleaBreak, + + /++ + + +/ + blockFloweringAzaleaFall, + + /++ + + +/ + blockFloweringAzaleaHit, + + /++ + + +/ + blockFloweringAzaleaPlace, + + /++ + + +/ + blockFloweringAzaleaStep, + + /++ + + +/ + entityFoxAggro, + + /++ + + +/ + entityFoxAmbient, + + /++ + + +/ + entityFoxBite, + + /++ + + +/ + entityFoxDeath, + + /++ + + +/ + entityFoxEat, + + /++ + + +/ + entityFoxHurt, + + /++ + + +/ + entityFoxScreech, + + /++ + + +/ + entityFoxSleep, + + /++ + + +/ + entityFoxSniff, + + /++ + + +/ + entityFoxSpit, + + /++ + + +/ + entityFoxTeleport, + + /++ + + +/ + blockSuspiciousSandBreak, + + /++ + + +/ + blockSuspiciousSandStep, + + /++ + + +/ + blockSuspiciousSandPlace, + + /++ + + +/ + blockSuspiciousSandHit, + + /++ + + +/ + blockSuspiciousSandFall, + + /++ + + +/ + blockSuspiciousGravelBreak, + + /++ + + +/ + blockSuspiciousGravelStep, + + /++ + + +/ + blockSuspiciousGravelPlace, + + /++ + + +/ + blockSuspiciousGravelHit, + + /++ + + +/ + blockSuspiciousGravelFall, + + /++ + + +/ + blockFroglightBreak, + + /++ + + +/ + blockFroglightFall, + + /++ + + +/ + blockFroglightHit, + + /++ + + +/ + blockFroglightPlace, + + /++ + + +/ + blockFroglightStep, + + /++ + + +/ + blockFrogspawnStep, + + /++ + + +/ + blockFrogspawnBreak, + + /++ + + +/ + blockFrogspawnFall, + + /++ + + +/ + blockFrogspawnHatch, + + /++ + + +/ + blockFrogspawnHit, + + /++ + + +/ + blockFrogspawnPlace, + + /++ + + +/ + entityFrogAmbient, + + /++ + + +/ + entityFrogDeath, + + /++ + + +/ + entityFrogEat, + + /++ + + +/ + entityFrogHurt, + + /++ + + +/ + entityFrogLaySpawn, + + /++ + + +/ + entityFrogLongJump, + + /++ + + +/ + entityFrogStep, + + /++ + + +/ + entityFrogTongue, + + /++ + + +/ + blockRootsBreak, + + /++ + + +/ + blockRootsStep, + + /++ + + +/ + blockRootsPlace, + + /++ + + +/ + blockRootsHit, + + /++ + + +/ + blockRootsFall, + + /++ + + +/ + blockFurnaceFireCrackle, + + /++ + + +/ + entityGenericBigFall, + + /++ + + +/ + entityGenericBurn, + + /++ + + +/ + entityGenericDeath, + + /++ + + +/ + entityGenericDrink, + + /++ + + +/ + entityGenericEat, + + /++ + + +/ + entityGenericExplode, + + /++ + + +/ + entityGenericExtinguishFire, + + /++ + + +/ + entityGenericHurt, + + /++ + + +/ + entityGenericSmallFall, + + /++ + + +/ + entityGenericSplash, + + /++ + + +/ + entityGenericSwim, + + /++ + + +/ + entityGhastAmbient, + + /++ + + +/ + entityGhastDeath, + + /++ + + +/ + entityGhastHurt, + + /++ + + +/ + entityGhastScream, + + /++ + + +/ + entityGhastShoot, + + /++ + + +/ + entityGhastWarn, + + /++ + + +/ + entityGhastlingAmbient, + + /++ + + +/ + entityGhastlingDeath, + + /++ + + +/ + entityGhastlingHurt, + + /++ + + +/ + entityGhastlingSpawn, + + /++ + + +/ + blockGildedBlackstoneBreak, + + /++ + + +/ + blockGildedBlackstoneFall, + + /++ + + +/ + blockGildedBlackstoneHit, + + /++ + + +/ + blockGildedBlackstonePlace, + + /++ + + +/ + blockGildedBlackstoneStep, + + /++ + + +/ + blockGlassBreak, + + /++ + + +/ + blockGlassFall, + + /++ + + +/ + blockGlassHit, + + /++ + + +/ + blockGlassPlace, + + /++ + + +/ + blockGlassStep, + + /++ + + +/ + itemGlowInkSacUse, + + /++ + + +/ + entityGlowItemFrameAddItem, + + /++ + + +/ + entityGlowItemFrameBreak, + + /++ + + +/ + entityGlowItemFramePlace, + + /++ + + +/ + entityGlowItemFrameRemoveItem, + + /++ + + +/ + entityGlowItemFrameRotateItem, + + /++ + + +/ + entityGlowSquidAmbient, + + /++ + + +/ + entityGlowSquidDeath, + + /++ + + +/ + entityGlowSquidHurt, + + /++ + + +/ + entityGlowSquidSquirt, + + /++ + + +/ + entityGoatAmbient, + + /++ + + +/ + entityGoatDeath, + + /++ + + +/ + entityGoatEat, + + /++ + + +/ + entityGoatHurt, + + /++ + + +/ + entityGoatLongJump, + + /++ + + +/ + entityGoatMilk, + + /++ + + +/ + entityGoatPrepareRam, + + /++ + + +/ + entityGoatRamImpact, + + /++ + + +/ + entityGoatHornBreak, + + /++ + + +/ + entityGoatScreamingAmbient, + + /++ + + +/ + entityGoatScreamingDeath, + + /++ + + +/ + entityGoatScreamingEat, + + /++ + + +/ + entityGoatScreamingHurt, + + /++ + + +/ + entityGoatScreamingLongJump, + + /++ + + +/ + entityGoatScreamingMilk, + + /++ + + +/ + entityGoatScreamingPrepareRam, + + /++ + + +/ + entityGoatScreamingRamImpact, + + /++ + + +/ + entityGoatStep, + + /++ + + +/ + itemGoldenDandelionUse, + + /++ + + +/ + itemGoldenDandelionUnuse, + + /++ + + +/ + blockGrassBreak, + + /++ + + +/ + blockGrassFall, + + /++ + + +/ + blockGrassHit, + + /++ + + +/ + blockGrassPlace, + + /++ + + +/ + blockGrassStep, + + /++ + + +/ + blockGravelBreak, + + /++ + + +/ + blockGravelFall, + + /++ + + +/ + blockGravelHit, + + /++ + + +/ + blockGravelPlace, + + /++ + + +/ + blockGravelStep, + + /++ + + +/ + blockGrindstoneUse, + + /++ + + +/ + blockGrowingPlantCrop, + + /++ + + +/ + entityGuardianAmbient, + + /++ + + +/ + entityGuardianAmbientLand, + + /++ + + +/ + entityGuardianAttack, + + /++ + + +/ + entityGuardianDeath, + + /++ + + +/ + entityGuardianDeathLand, + + /++ + + +/ + entityGuardianFlop, + + /++ + + +/ + entityGuardianHurt, + + /++ + + +/ + entityGuardianHurtLand, + + /++ + + +/ + blockHangingRootsBreak, + + /++ + + +/ + blockHangingRootsFall, + + /++ + + +/ + blockHangingRootsHit, + + /++ + + +/ + blockHangingRootsPlace, + + /++ + + +/ + blockHangingRootsStep, + + /++ + + +/ + blockHangingSignStep, + + /++ + + +/ + blockHangingSignBreak, + + /++ + + +/ + blockHangingSignFall, + + /++ + + +/ + blockHangingSignHit, + + /++ + + +/ + blockHangingSignPlace, + + /++ + + +/ + entityHappyGhastAmbient, + + /++ + + +/ + entityHappyGhastDeath, + + /++ + + +/ + entityHappyGhastHurt, + + /++ + + +/ + entityHappyGhastRiding, + + /++ + + +/ + blockHeavyCoreBreak, + + /++ + + +/ + blockHeavyCoreFall, + + /++ + + +/ + blockHeavyCoreHit, + + /++ + + +/ + blockHeavyCorePlace, + + /++ + + +/ + blockHeavyCoreStep, + + /++ + + +/ + blockNetherWoodHangingSignStep, + + /++ + + +/ + blockNetherWoodHangingSignBreak, + + /++ + + +/ + blockNetherWoodHangingSignFall, + + /++ + + +/ + blockNetherWoodHangingSignHit, + + /++ + + +/ + blockNetherWoodHangingSignPlace, + + /++ + + +/ + blockBambooWoodHangingSignStep, + + /++ + + +/ + blockBambooWoodHangingSignBreak, + + /++ + + +/ + blockBambooWoodHangingSignFall, + + /++ + + +/ + blockBambooWoodHangingSignHit, + + /++ + + +/ + blockBambooWoodHangingSignPlace, + + /++ + + +/ + blockTrialSpawnerBreak, + + /++ + + +/ + blockTrialSpawnerStep, + + /++ + + +/ + blockTrialSpawnerPlace, + + /++ + + +/ + blockTrialSpawnerHit, + + /++ + + +/ + blockTrialSpawnerFall, + + /++ + + +/ + blockTrialSpawnerSpawnMob, + + /++ + + +/ + blockTrialSpawnerAboutToSpawnItem, + + /++ + + +/ + blockTrialSpawnerSpawnItem, + + /++ + + +/ + blockTrialSpawnerSpawnItemBegin, + + /++ + + +/ + blockTrialSpawnerDetectPlayer, + + /++ + + +/ + blockTrialSpawnerOminousActivate, + + /++ + + +/ + blockTrialSpawnerAmbient, + + /++ + + +/ + blockTrialSpawnerAmbientOminous, + + /++ + + +/ + blockTrialSpawnerOpenShutter, + + /++ + + +/ + blockTrialSpawnerCloseShutter, + + /++ + + +/ + blockTrialSpawnerEjectItem, + + /++ + + +/ + entityHappyGhastEquip, + + /++ + + +/ + entityHappyGhastUnequip, + + /++ + + +/ + entityHappyGhastHarnessGogglesUp, + + /++ + + +/ + entityHappyGhastHarnessGogglesDown, + + /++ + + +/ + itemHoeTill, + + /++ + + +/ + entityHoglinAmbient, + + /++ + + +/ + entityHoglinAngry, + + /++ + + +/ + entityHoglinAttack, + + /++ + + +/ + entityHoglinConvertedToZombified, + + /++ + + +/ + entityHoglinDeath, + + /++ + + +/ + entityHoglinHurt, + + /++ + + +/ + entityHoglinRetreat, + + /++ + + +/ + entityHoglinStep, + + /++ + + +/ + blockHoneyBlockBreak, + + /++ + + +/ + blockHoneyBlockFall, + + /++ + + +/ + blockHoneyBlockHit, + + /++ + + +/ + blockHoneyBlockPlace, + + /++ + + +/ + blockHoneyBlockSlide, + + /++ + + +/ + blockHoneyBlockStep, + + /++ + + +/ + itemHoneycombWaxOn, + + /++ + + +/ + itemHoneyBottleDrink, + + /++ + + +/ + itemGoatHornSound0, + + /++ + + +/ + itemGoatHornSound1, + + /++ + + +/ + itemGoatHornSound2, + + /++ + + +/ + itemGoatHornSound3, + + /++ + + +/ + itemGoatHornSound4, + + /++ + + +/ + itemGoatHornSound5, + + /++ + + +/ + itemGoatHornSound6, + + /++ + + +/ + itemGoatHornSound7, + + /++ + + +/ + entityHorseAmbient, + + /++ + + +/ + entityBabyHorseAmbient, + + /++ + + +/ + entityHorseAngry, + + /++ + + +/ + entityBabyHorseAngry, + + /++ + + +/ + entityHorseArmor, + + /++ + + +/ + itemHorseArmorUnequip, + + /++ + + +/ + entityHorseBreathe, + + /++ + + +/ + entityBabyHorseBreathe, + + /++ + + +/ + entityHorseDeath, + + /++ + + +/ + entityBabyHorseDeath, + + /++ + + +/ + entityHorseEat, + + /++ + + +/ + entityBabyHorseEat, + + /++ + + +/ + entityHorseGallop, + + /++ + + +/ + entityHorseHurt, + + /++ + + +/ + entityBabyHorseHurt, + + /++ + + +/ + entityHorseJump, + + /++ + + +/ + entityHorseLand, + + /++ + + +/ + entityBabyHorseLand, + + /++ + + +/ + entityHorseSaddle, + + /++ + + +/ + entityHorseStep, + + /++ + + +/ + entityBabyHorseStep, + + /++ + + +/ + entityHorseStepWood, + + /++ + + +/ + entityHostileBigFall, + + /++ + + +/ + entityHostileDeath, + + /++ + + +/ + entityHostileHurt, + + /++ + + +/ + entityHostileSmallFall, + + /++ + + +/ + entityHostileSplash, + + /++ + + +/ + entityHostileSwim, + + /++ + + +/ + entityHuskAmbient, + + /++ + + +/ + entityHuskConvertedToZombie, + + /++ + + +/ + entityHuskDeath, + + /++ + + +/ + entityHuskHurt, + + /++ + + +/ + entityHuskStep, + + /++ + + +/ + entityIllusionerAmbient, + + /++ + + +/ + entityIllusionerCastSpell, + + /++ + + +/ + entityIllusionerDeath, + + /++ + + +/ + entityIllusionerHurt, + + /++ + + +/ + entityIllusionerMirrorMove, + + /++ + + +/ + entityIllusionerPrepareBlindness, + + /++ + + +/ + entityIllusionerPrepareMirror, + + /++ + + +/ + itemInkSacUse, + + /++ + + +/ + blockIronBreak, + + /++ + + +/ + blockIronStep, + + /++ + + +/ + blockIronPlace, + + /++ + + +/ + blockIronHit, + + /++ + + +/ + blockIronFall, + + /++ + + +/ + blockIronDoorClose, + + /++ + + +/ + blockIronDoorOpen, + + /++ + + +/ + entityIronGolemAttack, + + /++ + + +/ + entityIronGolemDamage, + + /++ + + +/ + entityIronGolemDeath, + + /++ + + +/ + entityIronGolemHurt, + + /++ + + +/ + entityIronGolemRepair, + + /++ + + +/ + entityIronGolemStep, + + /++ + + +/ + blockIronTrapdoorClose, + + /++ + + +/ + blockIronTrapdoorOpen, + + /++ + + +/ + entityItemFrameAddItem, + + /++ + + +/ + entityItemFrameBreak, + + /++ + + +/ + entityItemFramePlace, + + /++ + + +/ + entityItemFrameRemoveItem, + + /++ + + +/ + entityItemFrameRotateItem, + + /++ + + +/ + entityItemBreak, + + /++ + + +/ + entityItemPickup, + + /++ + + +/ + blockLadderBreak, + + /++ + + +/ + blockLadderFall, + + /++ + + +/ + blockLadderHit, + + /++ + + +/ + blockLadderPlace, + + /++ + + +/ + blockLadderStep, + + /++ + + +/ + blockLanternBreak, + + /++ + + +/ + blockLanternFall, + + /++ + + +/ + blockLanternHit, + + /++ + + +/ + blockLanternPlace, + + /++ + + +/ + blockLanternStep, + + /++ + + +/ + blockLargeAmethystBudBreak, + + /++ + + +/ + blockLargeAmethystBudPlace, + + /++ + + +/ + blockLavaAmbient, + + /++ + + +/ + blockLavaExtinguish, + + /++ + + +/ + blockLavaPop, + + /++ + + +/ + blockLeafLitterBreak, + + /++ + + +/ + blockLeafLitterStep, + + /++ + + +/ + blockLeafLitterPlace, + + /++ + + +/ + blockLeafLitterHit, + + /++ + + +/ + blockLeafLitterFall, + + /++ + + +/ + itemLeadUntied, + + /++ + + +/ + itemLeadTied, + + /++ + + +/ + itemLeadBreak, + + /++ + + +/ + blockLeverClick, + + /++ + + +/ + entityLightningBoltImpact, + + /++ + + +/ + entityLightningBoltThunder, + + /++ + + +/ + entityLingeringPotionThrow, + + /++ + + +/ + entityLlamaAmbient, + + /++ + + +/ + entityLlamaAngry, + + /++ + + +/ + entityLlamaChest, + + /++ + + +/ + entityLlamaDeath, + + /++ + + +/ + entityLlamaEat, + + /++ + + +/ + entityLlamaHurt, + + /++ + + +/ + entityLlamaSpit, + + /++ + + +/ + entityLlamaStep, + + /++ + + +/ + entityLlamaSwag, + + /++ + + +/ + itemLlamaCarpetUnequip, + + /++ + + +/ + entityMagmaCubeDeathSmall, + + /++ + + +/ + blockLodestoneBreak, + + /++ + + +/ + blockLodestoneStep, + + /++ + + +/ + blockLodestonePlace, + + /++ + + +/ + blockLodestoneHit, + + /++ + + +/ + blockLodestoneFall, + + /++ + + +/ + itemLodestoneCompassLock, + + /++ + + +/ + itemSpearLunge1, + + /++ + + +/ + itemSpearLunge2, + + /++ + + +/ + itemSpearLunge3, + + /++ + + +/ + itemMaceSmashAir, + + /++ + + +/ + itemMaceSmashGround, + + /++ + + +/ + itemMaceSmashGroundHeavy, + + /++ + + +/ + entityMagmaCubeDeath, + + /++ + + +/ + entityMagmaCubeHurt, + + /++ + + +/ + entityMagmaCubeHurtSmall, + + /++ + + +/ + entityMagmaCubeJump, + + /++ + + +/ + entityMagmaCubeSquish, + + /++ + + +/ + entityMagmaCubeSquishSmall, + + /++ + + +/ + blockMangroveRootsBreak, + + /++ + + +/ + blockMangroveRootsFall, + + /++ + + +/ + blockMangroveRootsHit, + + /++ + + +/ + blockMangroveRootsPlace, + + /++ + + +/ + blockMangroveRootsStep, + + /++ + + +/ + blockMediumAmethystBudBreak, + + /++ + + +/ + blockMediumAmethystBudPlace, + + /++ + + +/ + blockMetalBreak, + + /++ + + +/ + blockMetalFall, + + /++ + + +/ + blockMetalHit, + + /++ + + +/ + blockMetalPlace, + + /++ + + +/ + blockMetalPressurePlateClickOff, + + /++ + + +/ + blockMetalPressurePlateClickOn, + + /++ + + +/ + blockMetalStep, + + /++ + + +/ + entityMinecartInsideUnderwater, + + /++ + + +/ + entityMinecartInside, + + /++ + + +/ + entityMinecartRiding, + + /++ + + +/ + entityMooshroomConvert, + + /++ + + +/ + entityMooshroomEat, + + /++ + + +/ + entityMooshroomMilk, + + /++ + + +/ + entityMooshroomSuspiciousMilk, + + /++ + + +/ + entityMooshroomShear, + + /++ + + +/ + blockMossCarpetBreak, + + /++ + + +/ + blockMossCarpetFall, + + /++ + + +/ + blockMossCarpetHit, + + /++ + + +/ + blockMossCarpetPlace, + + /++ + + +/ + blockMossCarpetStep, + + /++ + + +/ + blockPinkPetalsBreak, + + /++ + + +/ + blockPinkPetalsFall, + + /++ + + +/ + blockPinkPetalsHit, + + /++ + + +/ + blockPinkPetalsPlace, + + /++ + + +/ + blockPinkPetalsStep, + + /++ + + +/ + blockMossBreak, + + /++ + + +/ + blockMossFall, + + /++ + + +/ + blockMossHit, + + /++ + + +/ + blockMossPlace, + + /++ + + +/ + blockMossStep, + + /++ + + +/ + blockMudBreak, + + /++ + + +/ + blockMudFall, + + /++ + + +/ + blockMudHit, + + /++ + + +/ + blockMudPlace, + + /++ + + +/ + blockMudStep, + + /++ + + +/ + blockMudBricksBreak, + + /++ + + +/ + blockMudBricksFall, + + /++ + + +/ + blockMudBricksHit, + + /++ + + +/ + blockMudBricksPlace, + + /++ + + +/ + blockMudBricksStep, + + /++ + + +/ + blockMuddyMangroveRootsBreak, + + /++ + + +/ + blockMuddyMangroveRootsFall, + + /++ + + +/ + blockMuddyMangroveRootsHit, + + /++ + + +/ + blockMuddyMangroveRootsPlace, + + /++ + + +/ + blockMuddyMangroveRootsStep, + + /++ + + +/ + entityMuleAmbient, + + /++ + + +/ + entityMuleAngry, + + /++ + + +/ + entityMuleChest, + + /++ + + +/ + entityMuleDeath, + + /++ + + +/ + entityMuleEat, + + /++ + + +/ + entityMuleHurt, + + /++ + + +/ + entityMuleJump, + + /++ + + +/ + musicCreative, + + /++ + + +/ + musicCredits, + + /++ + + +/ + musicDisc5, + + /++ + + +/ + musicDisc11, + + /++ + + +/ + musicDisc13, + + /++ + + +/ + musicDiscBlocks, + + /++ + + +/ + musicDiscBounce, + + /++ + + +/ + musicDiscCat, + + /++ + + +/ + musicDiscChirp, + + /++ + + +/ + musicDiscFar, + + /++ + + +/ + musicDiscLavaChicken, + + /++ + + +/ + musicDiscMall, + + /++ + + +/ + musicDiscMellohi, + + /++ + + +/ + musicDiscPigstep, + + /++ + + +/ + musicDiscStal, + + /++ + + +/ + musicDiscStrad, + + /++ + + +/ + musicDiscWait, + + /++ + + +/ + musicDiscWard, + + /++ + + +/ + musicDiscOtherside, + + /++ + + +/ + musicDiscRelic, + + /++ + + +/ + musicDiscCreator, + + /++ + + +/ + musicDiscCreatorMusicBox, + + /++ + + +/ + musicDiscPrecipice, + + /++ + + +/ + musicDiscTears, + + /++ + + +/ + musicDragon, + + /++ + + +/ + musicEnd, + + /++ + + +/ + musicGame, + + /++ + + +/ + musicMenu, + + /++ + + +/ + musicNetherBasaltDeltas, + + /++ + + +/ + musicNetherCrimsonForest, + + /++ + + +/ + musicOverworldDeepDark, + + /++ + + +/ + musicOverworldDripstoneCaves, + + /++ + + +/ + musicOverworldGrove, + + /++ + + +/ + musicOverworldJaggedPeaks, + + /++ + + +/ + musicOverworldLushCaves, + + /++ + + +/ + musicOverworldSwamp, + + /++ + + +/ + musicOverworldForest, + + /++ + + +/ + musicOverworldOldGrowthTaiga, + + /++ + + +/ + musicOverworldMeadow, + + /++ + + +/ + musicOverworldCherryGrove, + + /++ + + +/ + musicNetherNetherWastes, + + /++ + + +/ + musicOverworldFrozenPeaks, + + /++ + + +/ + musicOverworldSnowySlopes, + + /++ + + +/ + musicNetherSoulSandValley, + + /++ + + +/ + musicOverworldStonyPeaks, + + /++ + + +/ + musicNetherWarpedForest, + + /++ + + +/ + musicOverworldFlowerForest, + + /++ + + +/ + musicOverworldDesert, + + /++ + + +/ + musicOverworldBadlands, + + /++ + + +/ + musicOverworldJungle, + + /++ + + +/ + musicOverworldSparseJungle, + + /++ + + +/ + musicOverworldBambooJungle, + + /++ + + +/ + musicOverworldSulfurCaves, + + /++ + + +/ + musicUnderWater, + + /++ + + +/ + entityNautilusAmbient, + + /++ + + +/ + entityNautilusAmbientLand, + + /++ + + +/ + entityNautilusDash, + + /++ + + +/ + entityNautilusDashLand, + + /++ + + +/ + entityNautilusDashReady, + + /++ + + +/ + entityNautilusDashReadyLand, + + /++ + + +/ + entityNautilusDeath, + + /++ + + +/ + entityNautilusDeathLand, + + /++ + + +/ + entityNautilusEat, + + /++ + + +/ + entityNautilusHurt, + + /++ + + +/ + entityNautilusHurtLand, + + /++ + + +/ + entityNautilusSwim, + + /++ + + +/ + blockNetherBricksBreak, + + /++ + + +/ + blockNetherBricksStep, + + /++ + + +/ + blockNetherBricksPlace, + + /++ + + +/ + blockNetherBricksHit, + + /++ + + +/ + blockNetherBricksFall, + + /++ + + +/ + blockNetherWartBreak, + + /++ + + +/ + itemNetherWartPlant, + + /++ + + +/ + blockNetherWoodBreak, + + /++ + + +/ + blockNetherWoodFall, + + /++ + + +/ + blockNetherWoodHit, + + /++ + + +/ + blockNetherWoodPlace, + + /++ + + +/ + blockNetherWoodStep, + + /++ + + +/ + blockNetherWoodDoorClose, + + /++ + + +/ + blockNetherWoodDoorOpen, + + /++ + + +/ + blockNetherWoodTrapdoorClose, + + /++ + + +/ + blockNetherWoodTrapdoorOpen, + + /++ + + +/ + blockNetherWoodButtonClickOff, + + /++ + + +/ + blockNetherWoodButtonClickOn, + + /++ + + +/ + blockNetherWoodPressurePlateClickOff, + + /++ + + +/ + blockNetherWoodPressurePlateClickOn, + + /++ + + +/ + blockNetherWoodFenceGateClose, + + /++ + + +/ + blockNetherWoodFenceGateOpen, + + /++ + + +/ + intentionallyEmpty, + + /++ + + +/ + blockPackedMudBreak, + + /++ + + +/ + blockPackedMudFall, + + /++ + + +/ + blockPackedMudHit, + + /++ + + +/ + blockPackedMudPlace, + + /++ + + +/ + blockPackedMudStep, + + /++ + + +/ + blockStemBreak, + + /++ + + +/ + blockStemStep, + + /++ + + +/ + blockStemPlace, + + /++ + + +/ + blockStemHit, + + /++ + + +/ + blockStemFall, + + /++ + + +/ + blockNyliumBreak, + + /++ + + +/ + blockNyliumStep, + + /++ + + +/ + blockNyliumPlace, + + /++ + + +/ + blockNyliumHit, + + /++ + + +/ + blockNyliumFall, + + /++ + + +/ + blockNetherSproutsBreak, + + /++ + + +/ + blockNetherSproutsStep, + + /++ + + +/ + blockNetherSproutsPlace, + + /++ + + +/ + blockNetherSproutsHit, + + /++ + + +/ + blockNetherSproutsFall, + + /++ + + +/ + blockFungusBreak, + + /++ + + +/ + blockFungusStep, + + /++ + + +/ + blockFungusPlace, + + /++ + + +/ + blockFungusHit, + + /++ + + +/ + blockFungusFall, + + /++ + + +/ + blockWeepingVinesBreak, + + /++ + + +/ + blockWeepingVinesStep, + + /++ + + +/ + blockWeepingVinesPlace, + + /++ + + +/ + blockWeepingVinesHit, + + /++ + + +/ + blockWeepingVinesFall, + + /++ + + +/ + blockWartBlockBreak, + + /++ + + +/ + blockWartBlockStep, + + /++ + + +/ + blockWartBlockPlace, + + /++ + + +/ + blockWartBlockHit, + + /++ + + +/ + blockWartBlockFall, + + /++ + + +/ + blockNetheriteBlockBreak, + + /++ + + +/ + blockNetheriteBlockStep, + + /++ + + +/ + blockNetheriteBlockPlace, + + /++ + + +/ + blockNetheriteBlockHit, + + /++ + + +/ + blockNetheriteBlockFall, + + /++ + + +/ + blockNetherrackBreak, + + /++ + + +/ + blockNetherrackStep, + + /++ + + +/ + blockNetherrackPlace, + + /++ + + +/ + blockNetherrackHit, + + /++ + + +/ + blockNetherrackFall, + + /++ + + +/ + blockNoteBlockBasedrum, + + /++ + + +/ + blockNoteBlockBass, + + /++ + + +/ + blockNoteBlockBell, + + /++ + + +/ + blockNoteBlockChime, + + /++ + + +/ + blockNoteBlockFlute, + + /++ + + +/ + blockNoteBlockGuitar, + + /++ + + +/ + blockNoteBlockHarp, + + /++ + + +/ + blockNoteBlockHat, + + /++ + + +/ + blockNoteBlockPling, + + /++ + + +/ + blockNoteBlockSnare, + + /++ + + +/ + blockNoteBlockTrumpet, + + /++ + + +/ + blockNoteBlockTrumpetExposed, + + /++ + + +/ + blockNoteBlockTrumpetOxidized, + + /++ + + +/ + blockNoteBlockTrumpetWeathered, + + /++ + + +/ + blockNoteBlockXylophone, + + /++ + + +/ + blockNoteBlockIronXylophone, + + /++ + + +/ + blockNoteBlockCowBell, + + /++ + + +/ + blockNoteBlockDidgeridoo, + + /++ + + +/ + blockNoteBlockBit, + + /++ + + +/ + blockNoteBlockBanjo, + + /++ + + +/ + blockNoteBlockImitateZombie, + + /++ + + +/ + blockNoteBlockImitateSkeleton, + + /++ + + +/ + blockNoteBlockImitateCreeper, + + /++ + + +/ + blockNoteBlockImitateEnderDragon, + + /++ + + +/ + blockNoteBlockImitateWitherSkeleton, + + /++ + + +/ + blockNoteBlockImitatePiglin, + + /++ + + +/ + entityOcelotHurt, + + /++ + + +/ + entityOcelotAmbient, + + /++ + + +/ + entityOcelotDeath, + + /++ + + +/ + itemOminousBottleDispose, + + /++ + + +/ + entityPaintingBreak, + + /++ + + +/ + entityPaintingPlace, + + /++ + + +/ + blockPaleHangingMossIdle, + + /++ + + +/ + entityPandaPreSneeze, + + /++ + + +/ + entityPandaSneeze, + + /++ + + +/ + entityPandaAmbient, + + /++ + + +/ + entityPandaDeath, + + /++ + + +/ + entityPandaEat, + + /++ + + +/ + entityPandaStep, + + /++ + + +/ + entityPandaCantBreed, + + /++ + + +/ + entityPandaAggressiveAmbient, + + /++ + + +/ + entityPandaWorriedAmbient, + + /++ + + +/ + entityPandaHurt, + + /++ + + +/ + entityPandaBite, + + /++ + + +/ + entityParchedAmbient, + + /++ + + +/ + entityParchedDeath, + + /++ + + +/ + entityParchedHurt, + + /++ + + +/ + entityParchedStep, + + /++ + + +/ + entityParrotAmbient, + + /++ + + +/ + entityParrotDeath, + + /++ + + +/ + entityParrotEat, + + /++ + + +/ + entityParrotFly, + + /++ + + +/ + entityParrotHurt, + + /++ + + +/ + entityParrotImitateBlaze, + + /++ + + +/ + entityParrotImitateBogged, + + /++ + + +/ + entityParrotImitateBreeze, + + /++ + + +/ + entityParrotImitateCamelHusk, + + /++ + + +/ + entityParrotImitateCreaking, + + /++ + + +/ + entityParrotImitateCreeper, + + /++ + + +/ + entityParrotImitateDrowned, + + /++ + + +/ + entityParrotImitateElderGuardian, + + /++ + + +/ + entityParrotImitateEnderDragon, + + /++ + + +/ + entityParrotImitateEndermite, + + /++ + + +/ + entityParrotImitateEvoker, + + /++ + + +/ + entityParrotImitateGhast, + + /++ + + +/ + entityParrotImitateGuardian, + + /++ + + +/ + entityParrotImitateHoglin, + + /++ + + +/ + entityParrotImitateHusk, + + /++ + + +/ + entityParrotImitateIllusioner, + + /++ + + +/ + entityParrotImitateMagmaCube, + + /++ + + +/ + entityParrotImitatePhantom, + + /++ + + +/ + entityParrotImitateParched, + + /++ + + +/ + entityParrotImitatePiglin, + + /++ + + +/ + entityParrotImitatePiglinBrute, + + /++ + + +/ + entityParrotImitatePillager, + + /++ + + +/ + entityParrotImitateRavager, + + /++ + + +/ + entityParrotImitateShulker, + + /++ + + +/ + entityParrotImitateSilverfish, + + /++ + + +/ + entityParrotImitateSkeleton, + + /++ + + +/ + entityParrotImitateSlime, + + /++ + + +/ + entityParrotImitateSpider, + + /++ + + +/ + entityParrotImitateStray, + + /++ + + +/ + entityParrotImitateVex, + + /++ + + +/ + entityParrotImitateVindicator, + + /++ + + +/ + entityParrotImitateWarden, + + /++ + + +/ + entityParrotImitateWitch, + + /++ + + +/ + entityParrotImitateWither, + + /++ + + +/ + entityParrotImitateWitherSkeleton, + + /++ + + +/ + entityParrotImitateZoglin, + + /++ + + +/ + entityParrotImitateZombie, + + /++ + + +/ + entityParrotImitateZombieHorse, + + /++ + + +/ + entityParrotImitateZombieNautilus, + + /++ + + +/ + entityParrotImitateZombieVillager, + + /++ + + +/ + entityParrotStep, + + /++ + + +/ + entityPhantomAmbient, + + /++ + + +/ + entityPhantomBite, + + /++ + + +/ + entityPhantomDeath, + + /++ + + +/ + entityPhantomFlap, + + /++ + + +/ + entityPhantomHurt, + + /++ + + +/ + entityPhantomSwoop, + + /++ + + +/ + entityPigSaddle, + + /++ + + +/ + entityPigStep, + + /++ + + +/ + entityBabyPigStep, + + /++ + + +/ + entityBabyPigAmbient, + + /++ + + +/ + entityBabyPigEat, + + /++ + + +/ + entityBabyPigHurt, + + /++ + + +/ + entityBabyPigDeath, + + /++ + + +/ + entityPigAmbient, + + /++ + + +/ + entityPigHurt, + + /++ + + +/ + entityPigDeath, + + /++ + + +/ + entityPigEat, + + /++ + + +/ + entityPigMiniAmbient, + + /++ + + +/ + entityPigMiniHurt, + + /++ + + +/ + entityPigMiniDeath, + + /++ + + +/ + entityPigMiniEat, + + /++ + + +/ + entityPigBigAmbient, + + /++ + + +/ + entityPigBigHurt, + + /++ + + +/ + entityPigBigDeath, + + /++ + + +/ + entityPigBigEat, + + /++ + + +/ + entityPiglinAdmiringItem, + + /++ + + +/ + entityPiglinAmbient, + + /++ + + +/ + entityPiglinAngry, + + /++ + + +/ + entityPiglinCelebrate, + + /++ + + +/ + entityPiglinDeath, + + /++ + + +/ + entityPiglinJealous, + + /++ + + +/ + entityPiglinHurt, + + /++ + + +/ + entityPiglinRetreat, + + /++ + + +/ + entityPiglinStep, + + /++ + + +/ + entityPiglinConvertedToZombified, + + /++ + + +/ + entityPiglinBruteAmbient, + + /++ + + +/ + entityPiglinBruteAngry, + + /++ + + +/ + entityPiglinBruteDeath, + + /++ + + +/ + entityPiglinBruteHurt, + + /++ + + +/ + entityPiglinBruteStep, + + /++ + + +/ + entityPiglinBruteConvertedToZombified, + + /++ + + +/ + entityPillagerAmbient, + + /++ + + +/ + entityPillagerCelebrate, + + /++ + + +/ + entityPillagerDeath, + + /++ + + +/ + entityPillagerHurt, + + /++ + + +/ + blockPistonContract, + + /++ + + +/ + blockPistonExtend, + + /++ + + +/ + entityPlayerAttackCrit, + + /++ + + +/ + entityPlayerAttackKnockback, + + /++ + + +/ + entityPlayerAttackNodamage, + + /++ + + +/ + entityPlayerAttackStrong, + + /++ + + +/ + entityPlayerAttackSweep, + + /++ + + +/ + entityPlayerAttackWeak, + + /++ + + +/ + entityPlayerBigFall, + + /++ + + +/ + entityPlayerBreath, + + /++ + + +/ + entityPlayerBurp, + + /++ + + +/ + entityPlayerDeath, + + /++ + + +/ + entityPlayerHurt, + + /++ + + +/ + entityPlayerHurtDrown, + + /++ + + +/ + entityPlayerHurtFreeze, + + /++ + + +/ + entityPlayerHurtOnFire, + + /++ + + +/ + entityPlayerHurtSweetBerryBush, + + /++ + + +/ + entityPlayerLevelup, + + /++ + + +/ + entityPlayerSmallFall, + + /++ + + +/ + entityPlayerSplash, + + /++ + + +/ + entityPlayerSplashHighSpeed, + + /++ + + +/ + entityPlayerSwim, + + /++ + + +/ + entityPlayerTeleport, + + /++ + + +/ + entityPolarBearAmbient, + + /++ + + +/ + entityPolarBearAmbientBaby, + + /++ + + +/ + entityPolarBearDeath, + + /++ + + +/ + entityPolarBearHurt, + + /++ + + +/ + entityPolarBearStep, + + /++ + + +/ + entityPolarBearWarning, + + /++ + + +/ + blockPolishedDeepslateBreak, + + /++ + + +/ + blockPolishedDeepslateFall, + + /++ + + +/ + blockPolishedDeepslateHit, + + /++ + + +/ + blockPolishedDeepslatePlace, + + /++ + + +/ + blockPolishedDeepslateStep, + + /++ + + +/ + blockPortalAmbient, + + /++ + + +/ + blockPortalTravel, + + /++ + + +/ + blockPortalTrigger, + + /++ + + +/ + blockPowderSnowBreak, + + /++ + + +/ + blockPowderSnowFall, + + /++ + + +/ + blockPowderSnowHit, + + /++ + + +/ + blockPowderSnowPlace, + + /++ + + +/ + blockPowderSnowStep, + + /++ + + +/ + entityPufferFishBlowOut, + + /++ + + +/ + entityPufferFishBlowUp, + + /++ + + +/ + entityPufferFishDeath, + + /++ + + +/ + entityPufferFishFlop, + + /++ + + +/ + entityPufferFishHurt, + + /++ + + +/ + entityPufferFishSting, + + /++ + + +/ + blockPumpkinCarve, + + /++ + + +/ + entityRabbitAmbient, + + /++ + + +/ + entityRabbitAttack, + + /++ + + +/ + entityRabbitDeath, + + /++ + + +/ + entityRabbitHurt, + + /++ + + +/ + entityRabbitJump, + + /++ + + +/ + eventRaidHorn, + + /++ + + +/ + entityRavagerAmbient, + + /++ + + +/ + entityRavagerAttack, + + /++ + + +/ + entityRavagerCelebrate, + + /++ + + +/ + entityRavagerDeath, + + /++ + + +/ + entityRavagerHurt, + + /++ + + +/ + entityRavagerStep, + + /++ + + +/ + entityRavagerStunned, + + /++ + + +/ + entityRavagerRoar, + + /++ + + +/ + blockNetherGoldOreBreak, + + /++ + + +/ + blockNetherGoldOreFall, + + /++ + + +/ + blockNetherGoldOreHit, + + /++ + + +/ + blockNetherGoldOrePlace, + + /++ + + +/ + blockNetherGoldOreStep, + + /++ + + +/ + blockNetherOreBreak, + + /++ + + +/ + blockNetherOreFall, + + /++ + + +/ + blockNetherOreHit, + + /++ + + +/ + blockNetherOrePlace, + + /++ + + +/ + blockNetherOreStep, + + /++ + + +/ + blockRedstoneTorchBurnout, + + /++ + + +/ + blockResinBreak, + + /++ + + +/ + blockResinFall, + + /++ + + +/ + blockResinPlace, + + /++ + + +/ + blockResinStep, + + /++ + + +/ + blockResinBricksBreak, + + /++ + + +/ + blockResinBricksFall, + + /++ + + +/ + blockResinBricksHit, + + /++ + + +/ + blockResinBricksPlace, + + /++ + + +/ + blockResinBricksStep, + + /++ + + +/ + blockRespawnAnchorAmbient, + + /++ + + +/ + blockRespawnAnchorCharge, + + /++ + + +/ + blockRespawnAnchorDeplete, + + /++ + + +/ + blockRespawnAnchorSetSpawn, + + /++ + + +/ + blockRootedDirtBreak, + + /++ + + +/ + blockRootedDirtFall, + + /++ + + +/ + blockRootedDirtHit, + + /++ + + +/ + blockRootedDirtPlace, + + /++ + + +/ + blockRootedDirtStep, + + /++ + + +/ + entitySalmonAmbient, + + /++ + + +/ + entitySalmonDeath, + + /++ + + +/ + entitySalmonFlop, + + /++ + + +/ + entitySalmonHurt, + + /++ + + +/ + blockSandBreak, + + /++ + + +/ + blockSandFall, + + /++ + + +/ + blockSandHit, + + /++ + + +/ + blockSandPlace, + + /++ + + +/ + blockSandStep, + + /++ + + +/ + blockSandIdle, + + /++ + + +/ + blockScaffoldingBreak, + + /++ + + +/ + blockScaffoldingFall, + + /++ + + +/ + blockScaffoldingHit, + + /++ + + +/ + blockScaffoldingPlace, + + /++ + + +/ + blockScaffoldingStep, + + /++ + + +/ + blockSculkSpread, + + /++ + + +/ + blockSculkCharge, + + /++ + + +/ + blockSculkBreak, + + /++ + + +/ + blockSculkFall, + + /++ + + +/ + blockSculkHit, + + /++ + + +/ + blockSculkPlace, + + /++ + + +/ + blockSculkStep, + + /++ + + +/ + blockSculkCatalystBloom, + + /++ + + +/ + blockSculkCatalystBreak, + + /++ + + +/ + blockSculkCatalystFall, + + /++ + + +/ + blockSculkCatalystHit, + + /++ + + +/ + blockSculkCatalystPlace, + + /++ + + +/ + blockSculkCatalystStep, + + /++ + + +/ + blockSculkSensorClicking, + + /++ + + +/ + blockSculkSensorClickingStop, + + /++ + + +/ + blockSculkSensorBreak, + + /++ + + +/ + blockSculkSensorFall, + + /++ + + +/ + blockSculkSensorHit, + + /++ + + +/ + blockSculkSensorPlace, + + /++ + + +/ + blockSculkSensorStep, + + /++ + + +/ + blockSculkShriekerBreak, + + /++ + + +/ + blockSculkShriekerFall, + + /++ + + +/ + blockSculkShriekerHit, + + /++ + + +/ + blockSculkShriekerPlace, + + /++ + + +/ + blockSculkShriekerShriek, + + /++ + + +/ + blockSculkShriekerStep, + + /++ + + +/ + blockSculkVeinBreak, + + /++ + + +/ + blockSculkVeinFall, + + /++ + + +/ + blockSculkVeinHit, + + /++ + + +/ + blockSculkVeinPlace, + + /++ + + +/ + blockSculkVeinStep, + + /++ + + +/ + entitySheepAmbient, + + /++ + + +/ + entitySheepDeath, + + /++ + + +/ + entitySheepHurt, + + /++ + + +/ + entitySheepShear, + + /++ + + +/ + entitySheepStep, + + /++ + + +/ + itemShearsSnip, + + /++ + + +/ + blockShelfActivate, + + /++ + + +/ + blockShelfBreak, + + /++ + + +/ + blockShelfDeactivate, + + /++ + + +/ + blockShelfFall, + + /++ + + +/ + blockShelfHit, + + /++ + + +/ + blockShelfMultiSwap, + + /++ + + +/ + blockShelfPlace, + + /++ + + +/ + blockShelfPlaceItem, + + /++ + + +/ + blockShelfSingleSwap, + + /++ + + +/ + blockShelfStep, + + /++ + + +/ + blockShelfTakeItem, + + /++ + + +/ + itemShieldBlock, + + /++ + + +/ + itemShieldBreak, + + /++ + + +/ + blockShroomlightBreak, + + /++ + + +/ + blockShroomlightStep, + + /++ + + +/ + blockShroomlightPlace, + + /++ + + +/ + blockShroomlightHit, + + /++ + + +/ + blockShroomlightFall, + + /++ + + +/ + itemShovelFlatten, + + /++ + + +/ + entityShulkerAmbient, + + /++ + + +/ + blockShulkerBoxClose, + + /++ + + +/ + blockShulkerBoxOpen, + + /++ + + +/ + entityShulkerBulletHit, + + /++ + + +/ + entityShulkerBulletHurt, + + /++ + + +/ + entityShulkerClose, + + /++ + + +/ + entityShulkerDeath, + + /++ + + +/ + entityShulkerHurt, + + /++ + + +/ + entityShulkerHurtClosed, + + /++ + + +/ + entityShulkerOpen, + + /++ + + +/ + entityShulkerShoot, + + /++ + + +/ + entityShulkerTeleport, + + /++ + + +/ + entitySilverfishAmbient, + + /++ + + +/ + entitySilverfishDeath, + + /++ + + +/ + entitySilverfishHurt, + + /++ + + +/ + entitySilverfishStep, + + /++ + + +/ + entitySkeletonAmbient, + + /++ + + +/ + entitySkeletonConvertedToStray, + + /++ + + +/ + entitySkeletonDeath, + + /++ + + +/ + entitySkeletonHorseAmbient, + + /++ + + +/ + entitySkeletonHorseDeath, + + /++ + + +/ + entitySkeletonHorseHurt, + + /++ + + +/ + entitySkeletonHorseSwim, + + /++ + + +/ + entitySkeletonHorseAmbientWater, + + /++ + + +/ + entitySkeletonHorseGallopWater, + + /++ + + +/ + entitySkeletonHorseJumpWater, + + /++ + + +/ + entitySkeletonHorseStepWater, + + /++ + + +/ + entitySkeletonHurt, + + /++ + + +/ + entitySkeletonShoot, + + /++ + + +/ + entitySkeletonStep, + + /++ + + +/ + entitySlimeAttack, + + /++ + + +/ + entitySlimeDeath, + + /++ + + +/ + entitySlimeHurt, + + /++ + + +/ + entitySlimeJump, + + /++ + + +/ + entitySlimeSquish, + + /++ + + +/ + blockSlimeBlockBreak, + + /++ + + +/ + blockSlimeBlockFall, + + /++ + + +/ + blockSlimeBlockHit, + + /++ + + +/ + blockSlimeBlockPlace, + + /++ + + +/ + blockSlimeBlockStep, + + /++ + + +/ + blockSmallAmethystBudBreak, + + /++ + + +/ + blockSmallAmethystBudPlace, + + /++ + + +/ + blockSmallDripleafBreak, + + /++ + + +/ + blockSmallDripleafFall, + + /++ + + +/ + blockSmallDripleafHit, + + /++ + + +/ + blockSmallDripleafPlace, + + /++ + + +/ + blockSmallDripleafStep, + + /++ + + +/ + blockSoulSandBreak, + + /++ + + +/ + blockSoulSandStep, + + /++ + + +/ + blockSoulSandPlace, + + /++ + + +/ + blockSoulSandHit, + + /++ + + +/ + blockSoulSandFall, + + /++ + + +/ + blockSoulSoilBreak, + + /++ + + +/ + blockSoulSoilStep, + + /++ + + +/ + blockSoulSoilPlace, + + /++ + + +/ + blockSoulSoilHit, + + /++ + + +/ + blockSoulSoilFall, + + /++ + + +/ + particleSoulEscape, + + /++ + + +/ + blockSpawnerBreak, + + /++ + + +/ + blockSpawnerFall, + + /++ + + +/ + blockSpawnerHit, + + /++ + + +/ + blockSpawnerPlace, + + /++ + + +/ + blockSpawnerStep, + + /++ + + +/ + itemSpearUse, + + /++ + + +/ + itemSpearHit, + + /++ + + +/ + itemSpearAttack, + + /++ + + +/ + itemSpearWoodUse, + + /++ + + +/ + itemSpearWoodHit, + + /++ + + +/ + itemSpearWoodAttack, + + /++ + + +/ + blockSporeBlossomBreak, + + /++ + + +/ + blockSporeBlossomFall, + + /++ + + +/ + blockSporeBlossomHit, + + /++ + + +/ + blockSporeBlossomPlace, + + /++ + + +/ + blockSporeBlossomStep, + + /++ + + +/ + entityStriderAmbient, + + /++ + + +/ + entityStriderHappy, + + /++ + + +/ + entityStriderRetreat, + + /++ + + +/ + entityStriderDeath, + + /++ + + +/ + entityStriderHurt, + + /++ + + +/ + entityStriderStep, + + /++ + + +/ + entityStriderStepLava, + + /++ + + +/ + entityStriderEat, + + /++ + + +/ + entityStriderSaddle, + + /++ + + +/ + entitySlimeDeathSmall, + + /++ + + +/ + entitySlimeHurtSmall, + + /++ + + +/ + entitySlimeJumpSmall, + + /++ + + +/ + entitySlimeSquishSmall, + + /++ + + +/ + blockSmithingTableUse, + + /++ + + +/ + blockSmokerSmoke, + + /++ + + +/ + entitySnifferStep, + + /++ + + +/ + entitySnifferEat, + + /++ + + +/ + entitySnifferIdle, + + /++ + + +/ + entitySnifferHurt, + + /++ + + +/ + entitySnifferDeath, + + /++ + + +/ + entitySnifferDropSeed, + + /++ + + +/ + entitySnifferScenting, + + /++ + + +/ + entitySnifferSniffing, + + /++ + + +/ + entitySnifferSearching, + + /++ + + +/ + entitySnifferDigging, + + /++ + + +/ + entitySnifferDiggingStop, + + /++ + + +/ + entitySnifferHappy, + + /++ + + +/ + blockSnifferEggPlop, + + /++ + + +/ + blockSnifferEggCrack, + + /++ + + +/ + blockSnifferEggHatch, + + /++ + + +/ + entitySnowballThrow, + + /++ + + +/ + blockSnowBreak, + + /++ + + +/ + blockSnowFall, + + /++ + + +/ + entitySnowGolemAmbient, + + /++ + + +/ + entitySnowGolemDeath, + + /++ + + +/ + entitySnowGolemHurt, + + /++ + + +/ + entitySnowGolemShoot, + + /++ + + +/ + entitySnowGolemShear, + + /++ + + +/ + blockSnowHit, + + /++ + + +/ + blockSnowPlace, + + /++ + + +/ + blockSnowStep, + + /++ + + +/ + entitySpiderAmbient, + + /++ + + +/ + entitySpiderDeath, + + /++ + + +/ + entitySpiderHurt, + + /++ + + +/ + entitySpiderStep, + + /++ + + +/ + entitySplashPotionBreak, + + /++ + + +/ + entitySplashPotionThrow, + + /++ + + +/ + blockSpongeBreak, + + /++ + + +/ + blockSpongeFall, + + /++ + + +/ + blockSpongeHit, + + /++ + + +/ + blockSpongePlace, + + /++ + + +/ + blockSpongeStep, + + /++ + + +/ + blockSpongeAbsorb, + + /++ + + +/ + itemSpyglassUse, + + /++ + + +/ + itemSpyglassStopUsing, + + /++ + + +/ + entitySquidAmbient, + + /++ + + +/ + entitySquidDeath, + + /++ + + +/ + entitySquidHurt, + + /++ + + +/ + entitySquidSquirt, + + /++ + + +/ + blockStoneBreak, + + /++ + + +/ + blockStoneButtonClickOff, + + /++ + + +/ + blockStoneButtonClickOn, + + /++ + + +/ + blockStoneFall, + + /++ + + +/ + blockStoneHit, + + /++ + + +/ + blockStonePlace, + + /++ + + +/ + blockStonePressurePlateClickOff, + + /++ + + +/ + blockStonePressurePlateClickOn, + + /++ + + +/ + blockStoneStep, + + /++ + + +/ + entityStrayAmbient, + + /++ + + +/ + entityStrayDeath, + + /++ + + +/ + entityStrayHurt, + + /++ + + +/ + entityStrayStep, + + /++ + + +/ + blockSulfurSpikeBreak, + + /++ + + +/ + blockSulfurSpikeStep, + + /++ + + +/ + blockSulfurSpikePlace, + + /++ + + +/ + blockSulfurSpikeHit, + + /++ + + +/ + blockSulfurSpikeFall, + + /++ + + +/ + blockSulfurSpikeLand, + + /++ + + +/ + blockSweetBerryBushBreak, + + /++ + + +/ + blockSweetBerryBushPlace, + + /++ + + +/ + blockSweetBerryBushPickBerries, + + /++ + + +/ + entityTadpoleDeath, + + /++ + + +/ + entityTadpoleFlop, + + /++ + + +/ + entityTadpoleGrowUp, + + /++ + + +/ + entityTadpoleHurt, + + /++ + + +/ + enchantThornsHit, + + /++ + + +/ + entityTntPrimed, + + /++ + + +/ + itemTotemUse, + + /++ + + +/ + itemTridentHit, + + /++ + + +/ + itemTridentHitGround, + + /++ + + +/ + itemTridentReturn, + + /++ + + +/ + itemTridentRiptide1, + + /++ + + +/ + itemTridentRiptide2, + + /++ + + +/ + itemTridentRiptide3, + + /++ + + +/ + itemTridentThrow, + + /++ + + +/ + itemTridentThunder, + + /++ + + +/ + blockTripwireAttach, + + /++ + + +/ + blockTripwireClickOff, + + /++ + + +/ + blockTripwireClickOn, + + /++ + + +/ + blockTripwireDetach, + + /++ + + +/ + entityTropicalFishAmbient, + + /++ + + +/ + entityTropicalFishDeath, + + /++ + + +/ + entityTropicalFishFlop, + + /++ + + +/ + entityTropicalFishHurt, + + /++ + + +/ + blockTuffBreak, + + /++ + + +/ + blockTuffStep, + + /++ + + +/ + blockTuffPlace, + + /++ + + +/ + blockTuffHit, + + /++ + + +/ + blockTuffFall, + + /++ + + +/ + blockTuffBricksBreak, + + /++ + + +/ + blockTuffBricksFall, + + /++ + + +/ + blockTuffBricksHit, + + /++ + + +/ + blockTuffBricksPlace, + + /++ + + +/ + blockTuffBricksStep, + + /++ + + +/ + blockPolishedTuffBreak, + + /++ + + +/ + blockPolishedTuffFall, + + /++ + + +/ + blockPolishedTuffHit, + + /++ + + +/ + blockPolishedTuffPlace, + + /++ + + +/ + blockPolishedTuffStep, + + /++ + + +/ + entityTurtleAmbientLand, + + /++ + + +/ + entityTurtleDeath, + + /++ + + +/ + entityTurtleDeathBaby, + + /++ + + +/ + entityTurtleEggBreak, + + /++ + + +/ + entityTurtleEggCrack, + + /++ + + +/ + entityTurtleEggHatch, + + /++ + + +/ + entityTurtleHurt, + + /++ + + +/ + entityTurtleHurtBaby, + + /++ + + +/ + entityTurtleLayEgg, + + /++ + + +/ + entityTurtleShamble, + + /++ + + +/ + entityTurtleShambleBaby, + + /++ + + +/ + entityTurtleSwim, + + /++ + + +/ + uiButtonClick, + + /++ + + +/ + uiLoomSelectPattern, + + /++ + + +/ + uiLoomTakeResult, + + /++ + + +/ + uiCartographyTableTakeResult, + + /++ + + +/ + uiStonecutterTakeResult, + + /++ + + +/ + uiStonecutterSelectRecipe, + + /++ + + +/ + uiToastChallengeComplete, + + /++ + + +/ + uiToastIn, + + /++ + + +/ + uiToastOut, + + /++ + + +/ + blockVaultActivate, + + /++ + + +/ + blockVaultAmbient, + + /++ + + +/ + blockVaultBreak, + + /++ + + +/ + blockVaultCloseShutter, + + /++ + + +/ + blockVaultDeactivate, + + /++ + + +/ + blockVaultEjectItem, + + /++ + + +/ + blockVaultRejectRewardedPlayer, + + /++ + + +/ + blockVaultFall, + + /++ + + +/ + blockVaultHit, + + /++ + + +/ + blockVaultInsertItem, + + /++ + + +/ + blockVaultInsertItemFail, + + /++ + + +/ + blockVaultOpenShutter, + + /++ + + +/ + blockVaultPlace, + + /++ + + +/ + blockVaultStep, + + /++ + + +/ + entityVexAmbient, + + /++ + + +/ + entityVexCharge, + + /++ + + +/ + entityVexDeath, + + /++ + + +/ + entityVexHurt, + + /++ + + +/ + entityVillagerAmbient, + + /++ + + +/ + entityVillagerCelebrate, + + /++ + + +/ + entityVillagerDeath, + + /++ + + +/ + entityVillagerHurt, + + /++ + + +/ + entityVillagerNo, + + /++ + + +/ + entityVillagerTrade, + + /++ + + +/ + entityVillagerYes, + + /++ + + +/ + entityVillagerWorkArmorer, + + /++ + + +/ + entityVillagerWorkButcher, + + /++ + + +/ + entityVillagerWorkCartographer, + + /++ + + +/ + entityVillagerWorkCleric, + + /++ + + +/ + entityVillagerWorkFarmer, + + /++ + + +/ + entityVillagerWorkFisherman, + + /++ + + +/ + entityVillagerWorkFletcher, + + /++ + + +/ + entityVillagerWorkLeatherworker, + + /++ + + +/ + entityVillagerWorkLibrarian, + + /++ + + +/ + entityVillagerWorkMason, + + /++ + + +/ + entityVillagerWorkShepherd, + + /++ + + +/ + entityVillagerWorkToolsmith, + + /++ + + +/ + entityVillagerWorkWeaponsmith, + + /++ + + +/ + entityVindicatorAmbient, + + /++ + + +/ + entityVindicatorCelebrate, + + /++ + + +/ + entityVindicatorDeath, + + /++ + + +/ + entityVindicatorHurt, + + /++ + + +/ + blockVineBreak, + + /++ + + +/ + blockVineFall, + + /++ + + +/ + blockVineHit, + + /++ + + +/ + blockVinePlace, + + /++ + + +/ + blockVineStep, + + /++ + + +/ + blockLilyPadPlace, + + /++ + + +/ + entityWanderingTraderAmbient, + + /++ + + +/ + entityWanderingTraderDeath, + + /++ + + +/ + entityWanderingTraderDisappeared, + + /++ + + +/ + entityWanderingTraderDrinkMilk, + + /++ + + +/ + entityWanderingTraderDrinkPotion, + + /++ + + +/ + entityWanderingTraderHurt, + + /++ + + +/ + entityWanderingTraderNo, + + /++ + + +/ + entityWanderingTraderReappeared, + + /++ + + +/ + entityWanderingTraderTrade, + + /++ + + +/ + entityWanderingTraderYes, + + /++ + + +/ + entityWardenAgitated, + + /++ + + +/ + entityWardenAmbient, + + /++ + + +/ + entityWardenAngry, + + /++ + + +/ + entityWardenAttackImpact, + + /++ + + +/ + entityWardenDeath, + + /++ + + +/ + entityWardenDig, + + /++ + + +/ + entityWardenEmerge, + + /++ + + +/ + entityWardenHeartbeat, + + /++ + + +/ + entityWardenHurt, + + /++ + + +/ + entityWardenListening, + + /++ + + +/ + entityWardenListeningAngry, + + /++ + + +/ + entityWardenNearbyClose, + + /++ + + +/ + entityWardenNearbyCloser, + + /++ + + +/ + entityWardenNearbyClosest, + + /++ + + +/ + entityWardenRoar, + + /++ + + +/ + entityWardenSniff, + + /++ + + +/ + entityWardenSonicBoom, + + /++ + + +/ + entityWardenSonicCharge, + + /++ + + +/ + entityWardenStep, + + /++ + + +/ + entityWardenTendrilClicks, + + /++ + + +/ + blockHangingSignWaxedInteractFail, + + /++ + + +/ + blockSignWaxedInteractFail, + + /++ + + +/ + blockWaterAmbient, + + /++ + + +/ + weatherEndFlash, + + /++ + + +/ + weatherRain, + + /++ + + +/ + weatherRainAbove, + + /++ + + +/ + blockWetGrassBreak, + + /++ + + +/ + blockWetGrassFall, + + /++ + + +/ + blockWetGrassHit, + + /++ + + +/ + blockWetGrassPlace, + + /++ + + +/ + blockWetGrassStep, + + /++ + + +/ + blockWetSpongeBreak, + + /++ + + +/ + blockWetSpongeDries, + + /++ + + +/ + blockWetSpongeFall, + + /++ + + +/ + blockWetSpongeHit, + + /++ + + +/ + blockWetSpongePlace, + + /++ + + +/ + blockWetSpongeStep, + + /++ + + +/ + entityWindChargeWindBurst, + + /++ + + +/ + entityWindChargeThrow, + + /++ + + +/ + entityWitchAmbient, + + /++ + + +/ + entityWitchCelebrate, + + /++ + + +/ + entityWitchDeath, + + /++ + + +/ + entityWitchDrink, + + /++ + + +/ + entityWitchHurt, + + /++ + + +/ + entityWitchThrow, + + /++ + + +/ + entityWitherAmbient, + + /++ + + +/ + entityWitherBreakBlock, + + /++ + + +/ + entityWitherDeath, + + /++ + + +/ + entityWitherHurt, + + /++ + + +/ + entityWitherShoot, + + /++ + + +/ + entityWitherSkeletonAmbient, + + /++ + + +/ + entityWitherSkeletonDeath, + + /++ + + +/ + entityWitherSkeletonHurt, + + /++ + + +/ + entityWitherSkeletonStep, + + /++ + + +/ + entityWitherSpawn, + + /++ + + +/ + itemWolfArmorBreak, + + /++ + + +/ + entityBabyWolfAmbient, + + /++ + + +/ + itemWolfArmorCrack, + + /++ + + +/ + itemWolfArmorDamage, + + /++ + + +/ + itemWolfArmorRepair, + + /++ + + +/ + entityBabyWolfDeath, + + /++ + + +/ + entityBabyWolfGrowl, + + /++ + + +/ + entityBabyWolfHurt, + + /++ + + +/ + entityBabyWolfPant, + + /++ + + +/ + entityWolfShake, + + /++ + + +/ + entityWolfStep, + + /++ + + +/ + entityBabyWolfStep, + + /++ + + +/ + entityBabyWolfWhine, + + /++ + + +/ + entityWolfAmbient, + + /++ + + +/ + entityWolfDeath, + + /++ + + +/ + entityWolfGrowl, + + /++ + + +/ + entityWolfHurt, + + /++ + + +/ + entityWolfPant, + + /++ + + +/ + entityWolfWhine, + + /++ + + +/ + entityWolfPuglinAmbient, + + /++ + + +/ + entityWolfPuglinDeath, + + /++ + + +/ + entityWolfPuglinGrowl, + + /++ + + +/ + entityWolfPuglinHurt, + + /++ + + +/ + entityWolfPuglinPant, + + /++ + + +/ + entityWolfPuglinWhine, + + /++ + + +/ + entityWolfSadAmbient, + + /++ + + +/ + entityWolfSadDeath, + + /++ + + +/ + entityWolfSadGrowl, + + /++ + + +/ + entityWolfSadHurt, + + /++ + + +/ + entityWolfSadPant, + + /++ + + +/ + entityWolfSadWhine, + + /++ + + +/ + entityWolfAngryAmbient, + + /++ + + +/ + entityWolfAngryDeath, + + /++ + + +/ + entityWolfAngryGrowl, + + /++ + + +/ + entityWolfAngryHurt, + + /++ + + +/ + entityWolfAngryPant, + + /++ + + +/ + entityWolfAngryWhine, + + /++ + + +/ + entityWolfGrumpyAmbient, + + /++ + + +/ + entityWolfGrumpyDeath, + + /++ + + +/ + entityWolfGrumpyGrowl, + + /++ + + +/ + entityWolfGrumpyHurt, + + /++ + + +/ + entityWolfGrumpyPant, + + /++ + + +/ + entityWolfGrumpyWhine, + + /++ + + +/ + entityWolfBigAmbient, + + /++ + + +/ + entityWolfBigDeath, + + /++ + + +/ + entityWolfBigGrowl, + + /++ + + +/ + entityWolfBigHurt, + + /++ + + +/ + entityWolfBigPant, + + /++ + + +/ + entityWolfBigWhine, + + /++ + + +/ + entityWolfCuteAmbient, + + /++ + + +/ + entityWolfCuteDeath, + + /++ + + +/ + entityWolfCuteGrowl, + + /++ + + +/ + entityWolfCuteHurt, + + /++ + + +/ + entityWolfCutePant, + + /++ + + +/ + entityWolfCuteWhine, + + /++ + + +/ + blockWoodenDoorClose, + + /++ + + +/ + blockWoodenDoorOpen, + + /++ + + +/ + blockWoodenTrapdoorClose, + + /++ + + +/ + blockWoodenTrapdoorOpen, + + /++ + + +/ + blockWoodenButtonClickOff, + + /++ + + +/ + blockWoodenButtonClickOn, + + /++ + + +/ + blockWoodenPressurePlateClickOff, + + /++ + + +/ + blockWoodenPressurePlateClickOn, + + /++ + + +/ + blockWoodBreak, + + /++ + + +/ + blockWoodFall, + + /++ + + +/ + blockWoodHit, + + /++ + + +/ + blockWoodPlace, + + /++ + + +/ + blockWoodStep, + + /++ + + +/ + blockWoolBreak, + + /++ + + +/ + blockWoolFall, + + /++ + + +/ + blockWoolHit, + + /++ + + +/ + blockWoolPlace, + + /++ + + +/ + blockWoolStep, + + /++ + + +/ + entityZoglinAmbient, + + /++ + + +/ + entityZoglinAngry, + + /++ + + +/ + entityZoglinAttack, + + /++ + + +/ + entityZoglinDeath, + + /++ + + +/ + entityZoglinHurt, + + /++ + + +/ + entityZoglinStep, + + /++ + + +/ + entityZombieAmbient, + + /++ + + +/ + entityZombieAttackWoodenDoor, + + /++ + + +/ + entityZombieAttackIronDoor, + + /++ + + +/ + entityZombieBreakWoodenDoor, + + /++ + + +/ + entityZombieConvertedToDrowned, + + /++ + + +/ + entityZombieDeath, + + /++ + + +/ + entityZombieDestroyEgg, + + /++ + + +/ + entityZombieHorseAmbient, + + /++ + + +/ + entityZombieHorseAngry, + + /++ + + +/ + entityZombieHorseDeath, + + /++ + + +/ + entityZombieHorseEat, + + /++ + + +/ + entityZombieHorseHurt, + + /++ + + +/ + entityZombieHurt, + + /++ + + +/ + entityZombieInfect, + + /++ + + +/ + entityZombieNautilusAmbient, + + /++ + + +/ + entityZombieNautilusAmbientLand, + + /++ + + +/ + entityZombieNautilusDash, + + /++ + + +/ + entityZombieNautilusDashLand, + + /++ + + +/ + entityZombieNautilusDashReady, + + /++ + + +/ + entityZombieNautilusDashReadyLand, + + /++ + + +/ + entityZombieNautilusDeath, + + /++ + + +/ + entityZombieNautilusDeathLand, + + /++ + + +/ + entityZombieNautilusEat, + + /++ + + +/ + entityZombieNautilusHurt, + + /++ + + +/ + entityZombieNautilusHurtLand, + + /++ + + +/ + entityZombieNautilusSwim, + + /++ + + +/ + entityZombifiedPiglinAmbient, + + /++ + + +/ + entityZombifiedPiglinAngry, + + /++ + + +/ + entityZombifiedPiglinDeath, + + /++ + + +/ + entityZombifiedPiglinHurt, + + /++ + + +/ + entityZombieStep, + + /++ + + +/ + entityZombieVillagerAmbient, + + /++ + + +/ + entityZombieVillagerConverted, + + /++ + + +/ + entityZombieVillagerCure, + + /++ + + +/ + entityZombieVillagerDeath, + + /++ + + +/ + entityZombieVillagerHurt, + + /++ + + +/ + entityZombieVillagerStep, + + /++ + + +/ + eventMobEffectBadOmen, + + /++ + + +/ + eventMobEffectTrialOmen, + + /++ + + +/ + eventMobEffectRaidOmen, + + /++ + + +/ + itemSaddleUnequip, + + /++ + + +/ + itemNautilusSaddleUnderwaterEquip, + + /++ + + +/ + itemNautilusSaddleEquip, + + /++ + + +/ + blockSulfurBreak, + + /++ + + +/ + blockSulfurStep, + + /++ + + +/ + blockSulfurPlace, + + /++ + + +/ + blockSulfurHit, + + /++ + + +/ + blockSulfurFall, + + /++ + + +/ + blockPotentSulfurBreak, + + /++ + + +/ + blockPotentSulfurStep, + + /++ + + +/ + blockPotentSulfurPlace, + + /++ + + +/ + blockPotentSulfurHit, + + /++ + + +/ + blockPotentSulfurFall, + + /++ + + +/ + blockPotentSulfurGeyserEruption, + + /++ + + +/ + blockPotentSulfurGeyserEruptionActive, + + /++ + + +/ + blockPotentSulfurGeyserContinuousEruption, + + /++ + + +/ + blockPotentSulfurGeyserContinuousEruptionActive, + + /++ + + +/ + blockCinnabarBreak, + + /++ + + +/ + blockCinnabarStep, + + /++ + + +/ + blockCinnabarPlace, + + /++ + + +/ + blockCinnabarHit, + + /++ + + +/ + blockCinnabarFall, + + /++ + + +/ + entitySulfurCubeAbsorb, + + /++ + + +/ + entitySulfurCubeBounce, + + /++ + + +/ + entitySulfurCubeDeath, + + /++ + + +/ + entitySulfurCubeEject, + + /++ + + +/ + entitySulfurCubeHurt, + + /++ + + +/ + entitySulfurCubeJump, + + /++ + + +/ + entitySulfurCubeRegularHit, + + /++ + + +/ + entitySulfurCubeRegularPush, + + /++ + + +/ + entitySulfurCubeBouncyHit, + + /++ + + +/ + entitySulfurCubeBouncyPush, + + /++ + + +/ + entitySulfurCubeSlowBouncyHit, + + /++ + + +/ + entitySulfurCubeSlowBouncyPush, + + /++ + + +/ + entitySulfurCubeSlowFlatHit, + + /++ + + +/ + entitySulfurCubeSlowFlatPush, + + /++ + + +/ + entitySulfurCubeFastFlatHit, + + /++ + + +/ + entitySulfurCubeFastFlatPush, + + /++ + + +/ + entitySulfurCubeLightHit, + + /++ + + +/ + entitySulfurCubeLightPush, + + /++ + + +/ + entitySulfurCubeFastSlidingHit, + + /++ + + +/ + entitySulfurCubeFastSlidingPush, + + /++ + + +/ + entitySulfurCubeSlowSlidingHit, + + /++ + + +/ + entitySulfurCubeSlowSlidingPush, + + /++ + + +/ + entitySulfurCubeStickyHit, + + /++ + + +/ + entitySulfurCubeStickyPush, + + /++ + + +/ + entitySulfurCubeHighResistanceHit, + + /++ + + +/ + entitySulfurCubeHighResistancePush, + + /++ + + +/ + entitySulfurCubeExplosiveHit, + + /++ + + +/ + entitySulfurCubeExplosivePush, + + /++ + + +/ + entitySulfurCubeHotHit, + + /++ + + +/ + entitySulfurCubeHotPush, + + /++ + + +/ + entitySulfurCubeSquish, + + /++ + + +/ + blockPotentSulfurNoxiousGas, + + /++ + + +/ + entitySmallSulfurCubeDeath, + + /++ + + +/ + entitySmallSulfurCubeHurt, + + /++ + + +/ + entitySmallSulfurCubeJump, + + /++ + + +/ + entitySmallSulfurCubeSquish, + + /++ + + +/ + entitySmallSulfurCubeEat, +} \ No newline at end of file diff --git a/src/wit/pumpkin/plugin/sounds/imports.d b/src/wit/pumpkin/plugin/sounds/imports.d new file mode 100644 index 0000000..dc4d12c --- /dev/null +++ b/src/wit/pumpkin/plugin/sounds/imports.d @@ -0,0 +1,12 @@ +/++ + ++/ +module wit.pumpkin.plugin.sounds.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.sounds.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); diff --git a/src/wit/pumpkin/plugin/statistics/common.d b/src/wit/pumpkin/plugin/statistics/common.d new file mode 100644 index 0000000..f532732 --- /dev/null +++ b/src/wit/pumpkin/plugin/statistics/common.d @@ -0,0 +1,449 @@ +/++ + ++/ +module wit.pumpkin.plugin.statistics.common; + + +import wit.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +enum StatisticCategory : ubyte { + /++ + + +/ + mined, + + /++ + + +/ + crafted, + + /++ + + +/ + used, + + /++ + + +/ + broken, + + /++ + + +/ + pickedUp, + + /++ + + +/ + dropped, + + /++ + + +/ + killed, + + /++ + + +/ + killedBy, + + /++ + + +/ + custom, +} +/++ + ++/ +enum CustomStatistic : ubyte { + /++ + + +/ + leaveGame, + + /++ + + +/ + playTime, + + /++ + + +/ + totalWorldTime, + + /++ + + +/ + timeSinceDeath, + + /++ + + +/ + timeSinceRest, + + /++ + + +/ + sneakTime, + + /++ + + +/ + walkOneCm, + + /++ + + +/ + crouchOneCm, + + /++ + + +/ + sprintOneCm, + + /++ + + +/ + walkOnWaterOneCm, + + /++ + + +/ + fallOneCm, + + /++ + + +/ + climbOneCm, + + /++ + + +/ + flyOneCm, + + /++ + + +/ + walkUnderWaterOneCm, + + /++ + + +/ + minecartOneCm, + + /++ + + +/ + boatOneCm, + + /++ + + +/ + pigOneCm, + + /++ + + +/ + happyGhastOneCm, + + /++ + + +/ + horseOneCm, + + /++ + + +/ + aviateOneCm, + + /++ + + +/ + swimOneCm, + + /++ + + +/ + striderOneCm, + + /++ + + +/ + nautilusOneCm, + + /++ + + +/ + jump, + + /++ + + +/ + drop, + + /++ + + +/ + damageDealt, + + /++ + + +/ + damageDealtAbsorbed, + + /++ + + +/ + damageDealtResisted, + + /++ + + +/ + damageTaken, + + /++ + + +/ + damageBlockedByShield, + + /++ + + +/ + damageAbsorbed, + + /++ + + +/ + damageResisted, + + /++ + + +/ + deaths, + + /++ + + +/ + mobKills, + + /++ + + +/ + animalsBred, + + /++ + + +/ + playerKills, + + /++ + + +/ + fishCaught, + + /++ + + +/ + talkedToVillager, + + /++ + + +/ + tradedWithVillager, + + /++ + + +/ + eatCakeSlice, + + /++ + + +/ + fillCauldron, + + /++ + + +/ + useCauldron, + + /++ + + +/ + cleanArmor, + + /++ + + +/ + cleanBanner, + + /++ + + +/ + cleanShulkerBox, + + /++ + + +/ + interactWithBrewingstand, + + /++ + + +/ + interactWithBeacon, + + /++ + + +/ + inspectDropper, + + /++ + + +/ + inspectHopper, + + /++ + + +/ + inspectDispenser, + + /++ + + +/ + playNoteblock, + + /++ + + +/ + tuneNoteblock, + + /++ + + +/ + potFlower, + + /++ + + +/ + triggerTrappedChest, + + /++ + + +/ + openEnderchest, + + /++ + + +/ + enchantItem, + + /++ + + +/ + playRecord, + + /++ + + +/ + interactWithFurnace, + + /++ + + +/ + interactWithCraftingTable, + + /++ + + +/ + openChest, + + /++ + + +/ + sleepInBed, + + /++ + + +/ + openShulkerBox, + + /++ + + +/ + openBarrel, + + /++ + + +/ + interactWithBlastFurnace, + + /++ + + +/ + interactWithSmoker, + + /++ + + +/ + interactWithLectern, + + /++ + + +/ + interactWithCampfire, + + /++ + + +/ + interactWithCartographyTable, + + /++ + + +/ + interactWithLoom, + + /++ + + +/ + interactWithStonecutter, + + /++ + + +/ + bellRing, + + /++ + + +/ + raidTrigger, + + /++ + + +/ + raidWin, + + /++ + + +/ + interactWithAnvil, + + /++ + + +/ + interactWithGrindstone, + + /++ + + +/ + targetHit, + + /++ + + +/ + interactWithSmithingTable, +} \ No newline at end of file diff --git a/src/wit/pumpkin/plugin/statistics/imports.d b/src/wit/pumpkin/plugin/statistics/imports.d new file mode 100644 index 0000000..138d3a4 --- /dev/null +++ b/src/wit/pumpkin/plugin/statistics/imports.d @@ -0,0 +1,12 @@ +/++ + ++/ +module wit.pumpkin.plugin.statistics.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.statistics.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); diff --git a/src/wit/pumpkin/plugin/status_effect/common.d b/src/wit/pumpkin/plugin/status_effect/common.d new file mode 100644 index 0000000..7d2ad3c --- /dev/null +++ b/src/wit/pumpkin/plugin/status_effect/common.d @@ -0,0 +1,261 @@ +/++ + ++/ +module wit.pumpkin.plugin.status_effect.common; + + +import wit.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +enum StatusEffectType : ubyte { + /++ + + +/ + speed, + + /++ + + +/ + slowness, + + /++ + + +/ + haste, + + /++ + + +/ + miningFatigue, + + /++ + + +/ + strength, + + /++ + + +/ + instantHealth, + + /++ + + +/ + instantDamage, + + /++ + + +/ + jumpBoost, + + /++ + + +/ + nausea, + + /++ + + +/ + regeneration, + + /++ + + +/ + resistance, + + /++ + + +/ + fireResistance, + + /++ + + +/ + waterBreathing, + + /++ + + +/ + invisibility, + + /++ + + +/ + blindness, + + /++ + + +/ + nightVision, + + /++ + + +/ + hunger, + + /++ + + +/ + weakness, + + /++ + + +/ + poison, + + /++ + + +/ + wither, + + /++ + + +/ + healthBoost, + + /++ + + +/ + absorption, + + /++ + + +/ + saturation, + + /++ + + +/ + glowing, + + /++ + + +/ + levitation, + + /++ + + +/ + luck, + + /++ + + +/ + unluck, + + /++ + + +/ + slowFalling, + + /++ + + +/ + conduitPower, + + /++ + + +/ + dolphinsGrace, + + /++ + + +/ + badOmen, + + /++ + + +/ + heroOfTheVillage, + + /++ + + +/ + darkness, + + /++ + + +/ + trialOmen, + + /++ + + +/ + raidOmen, + + /++ + + +/ + windCharged, + + /++ + + +/ + weaving, + + /++ + + +/ + oozing, + + /++ + + +/ + infested, +} +/++ + ++/ +struct StatusEffectInstance { + /++ + + +/ + StatusEffectType effectType; + + /++ + + +/ + uint duration; + + /++ + + +/ + ubyte amplifier; + + /++ + + +/ + bool ambient; + + /++ + + +/ + bool showParticles; + + /++ + + +/ + bool showIcon; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + StatusEffectInstance witClone() const @nogc nothrow { + StatusEffectInstance clone = void; + clone.effectType = this.effectType.witClone; + clone.duration = this.duration.witClone; + clone.amplifier = this.amplifier.witClone; + clone.ambient = this.ambient.witClone; + clone.showParticles = this.showParticles.witClone; + clone.showIcon = this.showIcon.witClone; + return clone; + } +} diff --git a/src/wit/pumpkin/plugin/status_effect/imports.d b/src/wit/pumpkin/plugin/status_effect/imports.d new file mode 100644 index 0000000..458b887 --- /dev/null +++ b/src/wit/pumpkin/plugin/status_effect/imports.d @@ -0,0 +1,12 @@ +/++ + ++/ +module wit.pumpkin.plugin.status_effect.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.status_effect.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); diff --git a/src/wit/pumpkin/plugin/text/common.d b/src/wit/pumpkin/plugin/text/common.d new file mode 100644 index 0000000..b9577d3 --- /dev/null +++ b/src/wit/pumpkin/plugin/text/common.d @@ -0,0 +1,26 @@ +/++ + ++/ +module wit.pumpkin.plugin.text.common; + + +import wit.common; + +static import wit.pumpkin.plugin.common.common; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias NamedColor = wit.pumpkin.plugin.common.common.NamedColor; + +/++ + ++/ +alias RgbColor = wit.pumpkin.plugin.common.common.RgbColor; + +/++ + ++/ +alias ArgbColor = wit.pumpkin.plugin.common.common.ArgbColor; diff --git a/src/wit/pumpkin/plugin/text/imports.d b/src/wit/pumpkin/plugin/text/imports.d new file mode 100644 index 0000000..d2df8ad --- /dev/null +++ b/src/wit/pumpkin/plugin/text/imports.d @@ -0,0 +1,553 @@ +/++ + ++/ +module wit.pumpkin.plugin.text.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.text.common; + +static import wit.pumpkin.plugin.common.imports; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +struct TextComponent { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + /++ + Creates a plain text component. + +/ + static TextComponent text(in WitString plain) @trusted nothrow { + auto _ret = __import_text(cast(void*)(plain.ptr), plain.length); + auto _handle0 = TextComponent(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[static]text-component.text") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:static:text_component.text") + static private extern(C) uint __import_text(void*, size_t) nothrow; + + /++ + Creates a translation component. + +/ + static TextComponent translate(in WitString key, in WitList!(TextComponent) with_) @trusted nothrow { + auto _ret = __import_translate(cast(void*)(key.ptr), key.length, cast(void*)(with_.ptr), with_.length); + auto _handle0 = TextComponent(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[static]text-component.translate") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:static:text_component.translate") + static private extern(C) uint __import_translate(void*, size_t, void*, size_t) nothrow; + + /++ + Creates a translation component with a Bedrock-specific fallback key. + +/ + static TextComponent translateCross(in WitString javaKey, in WitString bedrockKey, in WitList!(TextComponent) with_) @trusted nothrow { + auto _ret = __import_translateCross(cast(void*)(javaKey.ptr), javaKey.length, cast(void*)(bedrockKey.ptr), bedrockKey.length, cast(void*)(with_.ptr), with_.length); + auto _handle0 = TextComponent(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[static]text-component.translate-cross") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:static:text_component.translate_cross") + static private extern(C) uint __import_translateCross(void*, size_t, void*, size_t, void*, size_t) nothrow; + + /++ + Creates an entity names / selector text component. + +/ + static TextComponent entityNames(in WitString selector, in Option!(WitString) separator) @trusted nothrow { + uint _option4 = void; + void* _option5 = void; + size_t _option6 = void; + if (separator.isSome) { + ref _payload3 = separator.unwrap(); + _option4 = 1; + _option5 = cast(void*)(_payload3.ptr); + _option6 = _payload3.length; + } else { + _option4 = 0; + _option5 = null; + _option6 = 0; + } + auto _ret = __import_entityNames(cast(void*)(selector.ptr), selector.length, _option4, _option5, _option6); + auto _handle7 = TextComponent(_ret); + return _handle7; + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[static]text-component.entity-names") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:static:text_component.entity_names") + static private extern(C) uint __import_entityNames(void*, size_t, uint, void*, size_t) nothrow; + + /++ + Creates a keybind text component (e.g., "key.jump"). + +/ + static TextComponent keybind(in WitString keybind) @trusted nothrow { + auto _ret = __import_keybind(cast(void*)(keybind.ptr), keybind.length); + auto _handle0 = TextComponent(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[static]text-component.keybind") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:static:text_component.keybind") + static private extern(C) uint __import_keybind(void*, size_t) nothrow; + + /++ + Creates a custom translation component. + +/ + static TextComponent custom(in WitString namespace, in WitString key, in WitString locale, in WitList!(TextComponent) with_) @trusted nothrow { + auto _ret = __import_custom(cast(void*)(namespace.ptr), namespace.length, cast(void*)(key.ptr), key.length, cast(void*)(locale.ptr), locale.length, cast(void*)(with_.ptr), with_.length); + auto _handle0 = TextComponent(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[static]text-component.custom") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:static:text_component.custom") + static private extern(C) uint __import_custom(void*, size_t, void*, size_t, void*, size_t, void*, size_t) nothrow; + + /++ + Parses a legacy Minecraft formatted string (using section signs '§' by default) into a text component. + +/ + static TextComponent fromLegacyString(in WitString input) @trusted nothrow { + auto _ret = __import_fromLegacyString(cast(void*)(input.ptr), input.length); + auto _handle0 = TextComponent(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[static]text-component.from-legacy-string") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:static:text_component.from_legacy_string") + static private extern(C) uint __import_fromLegacyString(void*, size_t) nothrow; + + /++ + Parses a legacy formatted string using a custom color code symbol (e.g. '&' or '§'). + +/ + static TextComponent fromLegacyStringWithCode(in WitString input, dchar codeSymbol) @trusted nothrow { + auto _ret = __import_fromLegacyStringWithCode(cast(void*)(input.ptr), input.length, cast(uint)(codeSymbol)); + auto _handle0 = TextComponent(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[static]text-component.from-legacy-string-with-code") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:static:text_component.from_legacy_string_with_code") + static private extern(C) uint __import_fromLegacyStringWithCode(void*, size_t, uint) nothrow; + + /++ + Parses a standard Minecraft JSON text component. + +/ + static Result!(TextComponent, WitString) fromJson(in WitString json) @trusted nothrow { + align(size_t.sizeof) void[(3*size_t.sizeof)] _retArea = void; + __import_fromJson(cast(void*)(json.ptr), json.length, _retArea.ptr); + Result!(TextComponent, WitString) _result5 = void; + bool _isErr5 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isErr5) { + auto _len3 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr3 = _len3 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list4 = WitString(_ptr3[0.._len3]); + + _result5 = Result!(TextComponent, WitString).makeErr(_list4); + } else { + auto _handle1 = TextComponent(*(cast(uint*)(_retArea.ptr + size_t.sizeof))); + + _result5 = Result!(TextComponent, WitString).makeOk(_handle1); + } + auto _flush6 = _result5; + return _flush6; + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[static]text-component.from-json") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:static:text_component.from_json") + static private extern(C) void __import_fromJson(void*, size_t, void*) nothrow; + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/text@0.1.0", "[resource-drop]text-component") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:resource_drop:text_component") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + Serializes the text component to JSON format. + +/ + WitString toJson() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_toJson(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.to-json") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.to_json") + static private extern(C) void __import_toJson(uint, void*) nothrow; + + /++ + + +/ + void addChild(TextComponent child) @trusted nothrow { + __import_addChild(this.__handle, child.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.add-child") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.add_child") + static private extern(C) void __import_addChild(uint, uint) nothrow; + + /++ + + +/ + void addText(in WitString text) @trusted nothrow { + __import_addText(this.__handle, cast(void*)(text.ptr), text.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.add-text") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.add_text") + static private extern(C) void __import_addText(uint, void*, size_t) nothrow; + + /++ + + +/ + WitString getText() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getText(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.get-text") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.get_text") + static private extern(C) void __import_getText(uint, void*) nothrow; + + /++ + + +/ + WitList!(ubyte) encode() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_encode(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(ubyte*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitList!(ubyte)(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.encode") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.encode") + static private extern(C) void __import_encode(uint, void*) nothrow; + + /++ + + +/ + WitString toPrettyConsole() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_toPrettyConsole(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.to-pretty-console") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.to_pretty_console") + static private extern(C) void __import_toPrettyConsole(uint, void*) nothrow; + + /++ + Style + +/ + void colorNamed(NamedColor color) @trusted nothrow { + __import_colorNamed(this.__handle, cast(uint)(color)); + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.color-named") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.color_named") + static private extern(C) void __import_colorNamed(uint, uint) nothrow; + + /++ + + +/ + void colorRgb(in RgbColor color) @trusted nothrow { + __import_colorRgb(this.__handle, cast(uint)(color.r), cast(uint)(color.g), cast(uint)(color.b)); + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.color-rgb") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.color_rgb") + static private extern(C) void __import_colorRgb(uint, uint, uint, uint) nothrow; + + /++ + + +/ + void gradientNamed(in WitList!(NamedColor) colors) @trusted nothrow { + wit.common.DeallocateBuffer deallocate; + auto _listSrc1 = colors; + auto _list1 = _listSrc1.length ? wit.common.malloc(_listSrc1.length * (1)) : null; + assert(!_listSrc1.length || _list1); + if (_listSrc1.length) deallocate ~= _list1; + foreach (_elem0_idx, ref _elem0; _listSrc1) { + auto _base0 = _list1 + _elem0_idx * (1); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(cast(uint)(_elem0)); + + } + __import_gradientNamed(this.__handle, _list1, colors.length); + deallocate.purge(); + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.gradient-named") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.gradient_named") + static private extern(C) void __import_gradientNamed(uint, void*, size_t) nothrow; + + /++ + + +/ + void gradient(in WitList!(RgbColor) colors) @trusted nothrow { + __import_gradient(this.__handle, cast(void*)(colors.ptr), colors.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.gradient") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.gradient") + static private extern(C) void __import_gradient(uint, void*, size_t) nothrow; + + /++ + + +/ + void rainbow() @trusted nothrow { + __import_rainbow(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.rainbow") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.rainbow") + static private extern(C) void __import_rainbow(uint) nothrow; + + /++ + + +/ + void bold(bool value) @trusted nothrow { + __import_bold(this.__handle, cast(uint)(value)); + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.bold") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.bold") + static private extern(C) void __import_bold(uint, uint) nothrow; + + /++ + + +/ + void italic(bool value) @trusted nothrow { + __import_italic(this.__handle, cast(uint)(value)); + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.italic") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.italic") + static private extern(C) void __import_italic(uint, uint) nothrow; + + /++ + + +/ + void underlined(bool value) @trusted nothrow { + __import_underlined(this.__handle, cast(uint)(value)); + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.underlined") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.underlined") + static private extern(C) void __import_underlined(uint, uint) nothrow; + + /++ + + +/ + void strikethrough(bool value) @trusted nothrow { + __import_strikethrough(this.__handle, cast(uint)(value)); + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.strikethrough") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.strikethrough") + static private extern(C) void __import_strikethrough(uint, uint) nothrow; + + /++ + + +/ + void obfuscated(bool value) @trusted nothrow { + __import_obfuscated(this.__handle, cast(uint)(value)); + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.obfuscated") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.obfuscated") + static private extern(C) void __import_obfuscated(uint, uint) nothrow; + + /++ + Text inserted into chat when shift-clicked + +/ + void insertion(in WitString text) @trusted nothrow { + __import_insertion(this.__handle, cast(void*)(text.ptr), text.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.insertion") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.insertion") + static private extern(C) void __import_insertion(uint, void*, size_t) nothrow; + + /++ + + +/ + void font(in WitString font) @trusted nothrow { + __import_font(this.__handle, cast(void*)(font.ptr), font.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.font") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.font") + static private extern(C) void __import_font(uint, void*, size_t) nothrow; + + /++ + + +/ + void shadowColor(in ArgbColor color) @trusted nothrow { + __import_shadowColor(this.__handle, cast(uint)(color.a), cast(uint)(color.r), cast(uint)(color.g), cast(uint)(color.b)); + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.shadow-color") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.shadow_color") + static private extern(C) void __import_shadowColor(uint, uint, uint, uint, uint) nothrow; + + /++ + Click events + +/ + void clickOpenUrl(in WitString url) @trusted nothrow { + __import_clickOpenUrl(this.__handle, cast(void*)(url.ptr), url.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.click-open-url") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.click_open_url") + static private extern(C) void __import_clickOpenUrl(uint, void*, size_t) nothrow; + + /++ + + +/ + void clickOpenFile(in WitString path) @trusted nothrow { + __import_clickOpenFile(this.__handle, cast(void*)(path.ptr), path.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.click-open-file") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.click_open_file") + static private extern(C) void __import_clickOpenFile(uint, void*, size_t) nothrow; + + /++ + + +/ + void clickRunCommand(in WitString command) @trusted nothrow { + __import_clickRunCommand(this.__handle, cast(void*)(command.ptr), command.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.click-run-command") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.click_run_command") + static private extern(C) void __import_clickRunCommand(uint, void*, size_t) nothrow; + + /++ + + +/ + void clickSuggestCommand(in WitString command) @trusted nothrow { + __import_clickSuggestCommand(this.__handle, cast(void*)(command.ptr), command.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.click-suggest-command") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.click_suggest_command") + static private extern(C) void __import_clickSuggestCommand(uint, void*, size_t) nothrow; + + /++ + + +/ + void clickChangePage(uint page) @trusted nothrow { + __import_clickChangePage(this.__handle, page); + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.click-change-page") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.click_change_page") + static private extern(C) void __import_clickChangePage(uint, uint) nothrow; + + /++ + + +/ + void clickCopyToClipboard(in WitString text) @trusted nothrow { + __import_clickCopyToClipboard(this.__handle, cast(void*)(text.ptr), text.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.click-copy-to-clipboard") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.click_copy_to_clipboard") + static private extern(C) void __import_clickCopyToClipboard(uint, void*, size_t) nothrow; + + /++ + Hover events + +/ + void hoverShowText(TextComponent text) @trusted nothrow { + __import_hoverShowText(this.__handle, text.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.hover-show-text") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.hover_show_text") + static private extern(C) void __import_hoverShowText(uint, uint) nothrow; + + /++ + Item data as SNBT string + +/ + void hoverShowItem(in WitString item) @trusted nothrow { + __import_hoverShowItem(this.__handle, cast(void*)(item.ptr), item.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.hover-show-item") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.hover_show_item") + static private extern(C) void __import_hoverShowItem(uint, void*, size_t) nothrow; + + /++ + + +/ + void hoverShowEntity(in WitString entityType, in WitString id, in Option!(TextComponent) name) @trusted nothrow { + uint _option4 = void; + uint _option5 = void; + if (name.isSome) { + ref _payload3 = name.unwrap(); + _option4 = 1; + _option5 = _payload3.__handle; + } else { + _option4 = 0; + _option5 = 0; + } + __import_hoverShowEntity(this.__handle, cast(void*)(entityType.ptr), entityType.length, cast(void*)(id.ptr), id.length, _option4, _option5); + } + /// ditto + @wasmImport!("pumpkin:plugin/text@0.1.0", "[method]text-component.hover-show-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__text@0.1.0__:method:text_component.hover_show_entity") + static private extern(C) void __import_hoverShowEntity(uint, void*, size_t, void*, size_t, uint, uint) nothrow; + } +} diff --git a/src/wit/pumpkin/plugin/uuid/common.d b/src/wit/pumpkin/plugin/uuid/common.d new file mode 100644 index 0000000..dcf128e --- /dev/null +++ b/src/wit/pumpkin/plugin/uuid/common.d @@ -0,0 +1,38 @@ +/++ + ++/ +module wit.pumpkin.plugin.uuid.common; + + +import wit.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ +A 128-bit UUID represented as two 64-bit integers. ++/ +struct Uuid { + /++ + + +/ + ulong high; + + /++ + + +/ + ulong low; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + Uuid witClone() const @nogc nothrow { + Uuid clone = void; + clone.high = this.high.witClone; + clone.low = this.low.witClone; + return clone; + } +} diff --git a/src/wit/pumpkin/plugin/uuid/imports.d b/src/wit/pumpkin/plugin/uuid/imports.d new file mode 100644 index 0000000..199206e --- /dev/null +++ b/src/wit/pumpkin/plugin/uuid/imports.d @@ -0,0 +1,73 @@ +/++ + ++/ +module wit.pumpkin.plugin.uuid.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.uuid.common; + + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ +Generates a new random v4 UUID. ++/ +Uuid generate() @trusted nothrow { + align(8) void[16] _retArea = void; + __import_generate(_retArea.ptr); + Uuid _record0 = { + high: *(cast(ulong*)(_retArea.ptr + 0)), + low: *(cast(ulong*)(_retArea.ptr + 8)), + }; + auto _flush1 = _record0; + return _flush1; +} +/// ditto +@wasmImport!("pumpkin:plugin/uuid@0.1.0", "generate") +pragma(mangle, "__wit_import_pumpkin:plugin__uuid@0.1.0__generate") +private extern(C) void __import_generate(void*) nothrow; + +/++ +Parses a UUID from a string. Returns none if the string is not a valid UUID. ++/ +Option!(Uuid) parse(in WitString s) @trusted nothrow { + align(8) void[24] _retArea = void; + __import_parse(cast(void*)(s.ptr), s.length, _retArea.ptr); + Option!(Uuid) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + Uuid _record2 = { + high: *(cast(ulong*)(_retArea.ptr + 8)), + low: *(cast(ulong*)(_retArea.ptr + 16)), + }; + + _option3 = Option!(Uuid).makeSome(_record2); + } else { + _option3 = Option!(Uuid).makeNone; + } + auto _flush4 = _option3; + return _flush4; +} +/// ditto +@wasmImport!("pumpkin:plugin/uuid@0.1.0", "parse") +pragma(mangle, "__wit_import_pumpkin:plugin__uuid@0.1.0__parse") +private extern(C) void __import_parse(void*, size_t, void*) nothrow; + +/++ +Converts a UUID to its standard string representation. ++/ +WitString toString(in Uuid id) @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_toString(id.high, id.low, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; +} +/// ditto +@wasmImport!("pumpkin:plugin/uuid@0.1.0", "to-string") +pragma(mangle, "__wit_import_pumpkin:plugin__uuid@0.1.0__to_string") +private extern(C) void __import_toString(ulong, ulong, void*) nothrow; diff --git a/src/wit/pumpkin/plugin/world/common.d b/src/wit/pumpkin/plugin/world/common.d new file mode 100644 index 0000000..391fac2 --- /dev/null +++ b/src/wit/pumpkin/plugin/world/common.d @@ -0,0 +1,2084 @@ +/++ + ++/ +module wit.pumpkin.plugin.world.common; + + +import wit.common; + +static import wit.pumpkin.plugin.attributes.common; +static import wit.pumpkin.plugin.biomes.common; +static import wit.pumpkin.plugin.common.common; +static import wit.pumpkin.plugin.damage_types.common; +static import wit.pumpkin.plugin.entity_types.common; +static import wit.pumpkin.plugin.game_rules.common; +static import wit.pumpkin.plugin.particles.common; +static import wit.pumpkin.plugin.sounds.common; +static import wit.pumpkin.plugin.text.common; +static import wit.pumpkin.plugin.item_stack.common; +static import wit.pumpkin.plugin.block_entity.common; +static import wit.pumpkin.plugin.scoreboard.common; +static import wit.pumpkin.plugin.uuid.common; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias Position = wit.pumpkin.plugin.common.common.Position; + +/++ + ++/ +alias EntityPose = wit.pumpkin.plugin.common.common.EntityPose; + +/++ + ++/ +alias BlockPos = wit.pumpkin.plugin.common.common.BlockPos; + +/++ + ++/ +alias NbtTree = wit.pumpkin.plugin.common.common.NbtTree; + +/++ + ++/ +alias Particle = wit.pumpkin.plugin.particles.common.Particle; + +/++ + ++/ +alias Sound = wit.pumpkin.plugin.sounds.common.Sound; + +/++ + ++/ +alias SoundCategory = wit.pumpkin.plugin.sounds.common.SoundCategory; + +/++ + ++/ +alias EntityType = wit.pumpkin.plugin.entity_types.common.EntityType; + +/++ + ++/ +alias Biome = wit.pumpkin.plugin.biomes.common.Biome; + +/++ + ++/ +alias Attribute = wit.pumpkin.plugin.attributes.common.Attribute; + +/++ + ++/ +alias ModifierOperation = wit.pumpkin.plugin.attributes.common.ModifierOperation; + +/++ + ++/ +alias AttributeModifier = wit.pumpkin.plugin.attributes.common.AttributeModifier; + +/++ + ++/ +alias DamageType = wit.pumpkin.plugin.damage_types.common.DamageType; + +/++ + ++/ +alias GameRule = wit.pumpkin.plugin.game_rules.common.GameRule; + +/++ + ++/ +alias GameRuleValue = wit.pumpkin.plugin.game_rules.common.GameRuleValue; + +/++ + ++/ +alias Uuid = wit.pumpkin.plugin.uuid.common.Uuid; + +/++ +Equipment slots available on living entities (mobs, armor stands, players). ++/ +enum EquipmentSlot : ubyte { + /++ + + +/ + mainHand, + + /++ + + +/ + offHand, + + /++ + + +/ + feet, + + /++ + + +/ + legs, + + /++ + + +/ + chest, + + /++ + + +/ + head, + + /++ + + +/ + body_, + + /++ + + +/ + saddle, +} +/++ +Defines how a block reacts when pushed by a piston. ++/ +enum PistonBehavior : ubyte { + /++ + Normal behavior; the block can be pushed and pulled. + +/ + normal, + + /++ + The block is destroyed when pushed. + +/ + destroy, + + /++ + The block cannot be pushed or pulled. + +/ + block, + + /++ + The block is ignored by pistons. + +/ + ignore, + + /++ + The block can only be pushed, not pulled. + +/ + pushOnly, +} +/++ +Predefined AI goals that can be added to mob entities. ++/ +struct BuiltinAiGoal { + mixin WitVariant!( + void, // swim + float, // wanderAround + float, // meleeAttack + float, // lookAtPlayer + void, // lookAround + float, // escapeDanger + float, // avoidEntity + void, // blazeAttack + void, // creeperIgnite + void, // eatGrass + float, // zombieAttack + ); + +public: + enum Tag : ubyte { + /++ + + +/ + swim, + + /++ + + +/ + wanderAround, + + /++ + + +/ + meleeAttack, + + /++ + + +/ + lookAtPlayer, + + /++ + + +/ + lookAround, + + /++ + + +/ + escapeDanger, + + /++ + + +/ + avoidEntity, + + /++ + + +/ + blazeAttack, + + /++ + + +/ + creeperIgnite, + + /++ + + +/ + eatGrass, + + /++ + + +/ + zombieAttack, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias swim = _create!(Tag.swim); + /// ditto + pragma(inline, true) bool isSwim() const => _tag == Tag.swim; + + /++ + + +/ + alias wanderAround = _create!(Tag.wanderAround); + /// ditto + pragma(inline, true) bool isWanderAround() const => _tag == Tag.wanderAround; + ///ditto + alias getWanderAround = _get!(Tag.wanderAround); + + /++ + + +/ + alias meleeAttack = _create!(Tag.meleeAttack); + /// ditto + pragma(inline, true) bool isMeleeAttack() const => _tag == Tag.meleeAttack; + ///ditto + alias getMeleeAttack = _get!(Tag.meleeAttack); + + /++ + + +/ + alias lookAtPlayer = _create!(Tag.lookAtPlayer); + /// ditto + pragma(inline, true) bool isLookAtPlayer() const => _tag == Tag.lookAtPlayer; + ///ditto + alias getLookAtPlayer = _get!(Tag.lookAtPlayer); + + /++ + + +/ + alias lookAround = _create!(Tag.lookAround); + /// ditto + pragma(inline, true) bool isLookAround() const => _tag == Tag.lookAround; + + /++ + + +/ + alias escapeDanger = _create!(Tag.escapeDanger); + /// ditto + pragma(inline, true) bool isEscapeDanger() const => _tag == Tag.escapeDanger; + ///ditto + alias getEscapeDanger = _get!(Tag.escapeDanger); + + /++ + + +/ + alias avoidEntity = _create!(Tag.avoidEntity); + /// ditto + pragma(inline, true) bool isAvoidEntity() const => _tag == Tag.avoidEntity; + ///ditto + alias getAvoidEntity = _get!(Tag.avoidEntity); + + /++ + + +/ + alias blazeAttack = _create!(Tag.blazeAttack); + /// ditto + pragma(inline, true) bool isBlazeAttack() const => _tag == Tag.blazeAttack; + + /++ + + +/ + alias creeperIgnite = _create!(Tag.creeperIgnite); + /// ditto + pragma(inline, true) bool isCreeperIgnite() const => _tag == Tag.creeperIgnite; + + /++ + + +/ + alias eatGrass = _create!(Tag.eatGrass); + /// ditto + pragma(inline, true) bool isEatGrass() const => _tag == Tag.eatGrass; + + /++ + + +/ + alias zombieAttack = _create!(Tag.zombieAttack); + /// ditto + pragma(inline, true) bool isZombieAttack() const => _tag == Tag.zombieAttack; + ///ditto + alias getZombieAttack = _get!(Tag.zombieAttack); + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + BuiltinAiGoal witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.swim: return _create!(Tag.swim); break; + case Tag.wanderAround: return _create!(Tag.wanderAround)(this._get!(Tag.wanderAround).witClone); break; + case Tag.meleeAttack: return _create!(Tag.meleeAttack)(this._get!(Tag.meleeAttack).witClone); break; + case Tag.lookAtPlayer: return _create!(Tag.lookAtPlayer)(this._get!(Tag.lookAtPlayer).witClone); break; + case Tag.lookAround: return _create!(Tag.lookAround); break; + case Tag.escapeDanger: return _create!(Tag.escapeDanger)(this._get!(Tag.escapeDanger).witClone); break; + case Tag.avoidEntity: return _create!(Tag.avoidEntity)(this._get!(Tag.avoidEntity).witClone); break; + case Tag.blazeAttack: return _create!(Tag.blazeAttack); break; + case Tag.creeperIgnite: return _create!(Tag.creeperIgnite); break; + case Tag.eatGrass: return _create!(Tag.eatGrass); break; + case Tag.zombieAttack: return _create!(Tag.zombieAttack)(this._get!(Tag.zombieAttack).witClone); break; + } + } +} + +/++ +Node and terrain classification types evaluated during mob pathfinding. ++/ +enum PathNodeType : ubyte { + /++ + + +/ + blocked, + + /++ + + +/ + open, + + /++ + + +/ + walkable, + + /++ + + +/ + walkableDoor, + + /++ + + +/ + trapdoor, + + /++ + + +/ + powderSnow, + + /++ + + +/ + dangerPowderSnow, + + /++ + + +/ + fence, + + /++ + + +/ + lava, + + /++ + + +/ + water, + + /++ + + +/ + waterBorder, + + /++ + + +/ + rail, + + /++ + + +/ + unpassableRail, + + /++ + + +/ + dangerFire, + + /++ + + +/ + damageFire, + + /++ + + +/ + dangerOther, + + /++ + + +/ + damageOther, + + /++ + + +/ + doorOpen, + + /++ + + +/ + doorWoodClosed, + + /++ + + +/ + doorIronClosed, + + /++ + + +/ + breach, + + /++ + + +/ + leaves, + + /++ + + +/ + stickyHoney, + + /++ + + +/ + cocoa, + + /++ + + +/ + damageCautious, + + /++ + + +/ + dangerTrapdoor, +} +/++ +Minecraft 16 dye colors. ++/ +enum DyeColor : ubyte { + /++ + + +/ + white, + + /++ + + +/ + orange, + + /++ + + +/ + magenta, + + /++ + + +/ + lightBlue, + + /++ + + +/ + yellow, + + /++ + + +/ + lime, + + /++ + + +/ + pink, + + /++ + + +/ + gray, + + /++ + + +/ + lightGray, + + /++ + + +/ + cyan, + + /++ + + +/ + purple, + + /++ + + +/ + blue, + + /++ + + +/ + brown, + + /++ + + +/ + green, + + /++ + + +/ + red, + + /++ + + +/ + black, +} +/++ +Villager profession identifiers. ++/ +enum VillagerProfession : ubyte { + /++ + + +/ + none, + + /++ + + +/ + armorer, + + /++ + + +/ + butcher, + + /++ + + +/ + cartographer, + + /++ + + +/ + cleric, + + /++ + + +/ + farmer, + + /++ + + +/ + fisherman, + + /++ + + +/ + fletcher, + + /++ + + +/ + leatherworker, + + /++ + + +/ + librarian, + + /++ + + +/ + mason, + + /++ + + +/ + nitwit, + + /++ + + +/ + shepherd, + + /++ + + +/ + toolsmith, + + /++ + + +/ + weaponsmith, +} +/++ +Specialized data for sheep entities. ++/ +struct SheepData { + /++ + + +/ + DyeColor color; + + /++ + + +/ + bool isSheared; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SheepData witClone() const @nogc nothrow { + SheepData clone = void; + clone.color = this.color.witClone; + clone.isSheared = this.isSheared.witClone; + return clone; + } +} + +/++ +Specialized data for wolf entities. ++/ +struct WolfData { + /++ + + +/ + bool isTamed; + + /++ + + +/ + Option!(Uuid) owner; + + /++ + + +/ + bool isSitting; + + /++ + + +/ + DyeColor collarColor; + + /++ + + +/ + bool isAngry; + + /++ + + +/ + bool isBegging; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + WolfData witClone() const @nogc nothrow { + WolfData clone = void; + clone.isTamed = this.isTamed.witClone; + clone.owner = this.owner.witClone; + clone.isSitting = this.isSitting.witClone; + clone.collarColor = this.collarColor.witClone; + clone.isAngry = this.isAngry.witClone; + clone.isBegging = this.isBegging.witClone; + return clone; + } +} + +/++ +Specialized data for cat entities. ++/ +struct CatData { + /++ + + +/ + bool isTamed; + + /++ + + +/ + Option!(Uuid) owner; + + /++ + + +/ + bool isSitting; + + /++ + + +/ + DyeColor collarColor; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CatData witClone() const @nogc nothrow { + CatData clone = void; + clone.isTamed = this.isTamed.witClone; + clone.owner = this.owner.witClone; + clone.isSitting = this.isSitting.witClone; + clone.collarColor = this.collarColor.witClone; + return clone; + } +} + +/++ +Specialized data for villager entities. ++/ +struct VillagerData { + /++ + + +/ + VillagerProfession profession; + + /++ + + +/ + ubyte level; + + /++ + + +/ + uint experience; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + VillagerData witClone() const @nogc nothrow { + VillagerData clone = void; + clone.profession = this.profession.witClone; + clone.level = this.level.witClone; + clone.experience = this.experience.witClone; + return clone; + } +} + +/++ +Specialized data for creeper entities. ++/ +struct CreeperData { + /++ + + +/ + bool isPowered; + + /++ + + +/ + int fuse; + + /++ + + +/ + bool isIgnited; + + /++ + + +/ + ubyte explosionRadius; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + CreeperData witClone() const @nogc nothrow { + CreeperData clone = void; + clone.isPowered = this.isPowered.witClone; + clone.fuse = this.fuse.witClone; + clone.isIgnited = this.isIgnited.witClone; + clone.explosionRadius = this.explosionRadius.witClone; + return clone; + } +} + +/++ +Specialized data for slime and magma cube entities. ++/ +struct SlimeData { + /++ + + +/ + int size; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + SlimeData witClone() const @nogc nothrow { + SlimeData clone = void; + clone.size = this.size.witClone; + return clone; + } +} + +/++ +Specialized data for enderman entities. ++/ +struct EndermanData { + /++ + + +/ + Option!(ushort) carriedBlockState; + + /++ + + +/ + bool isScreaming; + + /++ + + +/ + bool isStaring; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + EndermanData witClone() const @nogc nothrow { + EndermanData clone = void; + clone.carriedBlockState = this.carriedBlockState.witClone; + clone.isScreaming = this.isScreaming.witClone; + clone.isStaring = this.isStaring.witClone; + return clone; + } +} + +/++ +Specialized data for iron golem entities. ++/ +struct IronGolemData { + /++ + + +/ + bool isPlayerCreated; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + IronGolemData witClone() const @nogc nothrow { + IronGolemData clone = void; + clone.isPlayerCreated = this.isPlayerCreated.witClone; + return clone; + } +} + +/++ +Specialized data for fox entities. ++/ +struct FoxData { + /++ + + +/ + bool isSitting; + + /++ + + +/ + bool isSleeping; + + /++ + + +/ + bool isCrouching; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + FoxData witClone() const @nogc nothrow { + FoxData clone = void; + clone.isSitting = this.isSitting.witClone; + clone.isSleeping = this.isSleeping.witClone; + clone.isCrouching = this.isCrouching.witClone; + return clone; + } +} + +/++ +Specialized data for ageable animal mobs. ++/ +struct AgeableData { + /++ + + +/ + bool isBaby; + + /++ + + +/ + int age; + + /++ + + +/ + int inLoveTicks; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + AgeableData witClone() const @nogc nothrow { + AgeableData clone = void; + clone.isBaby = this.isBaby.witClone; + clone.age = this.age.witClone; + clone.inLoveTicks = this.inLoveTicks.witClone; + return clone; + } +} + +/++ +Specialized data for zombie entities. ++/ +struct ZombieData { + /++ + + +/ + bool isBaby; + + /++ + + +/ + bool canBreakDoors; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ZombieData witClone() const @nogc nothrow { + ZombieData clone = void; + clone.isBaby = this.isBaby.witClone; + clone.canBreakDoors = this.canBreakDoors.witClone; + return clone; + } +} + +/++ +Defines how an explosion interacts with blocks in the world. ++/ +enum ExplosionInteraction : ubyte { + /++ + No interaction with blocks. + +/ + none, + + /++ + Blocks are destroyed and may drop loot. + +/ + block, + + /++ + Interaction typical for mob-caused explosions. + +/ + mob, + + /++ + Interaction typical for TNT explosions. + +/ + tnt, + + /++ + Triggers specific block behaviors. + +/ + trigger, +} +/++ +Flags used to control block updates and notifications. ++/ +struct BlockFlags { + mixin WitFlags!ubyte; + + /++ + Notifies neighbor blocks of the change. + +/ + enum notifyNeighbors = BlockFlags[0]; + + /++ + Notifies client listeners of the change. + +/ + enum notifyListeners = BlockFlags[1]; + + /++ + Forces the block state even if it's the same. + +/ + enum forceState = BlockFlags[2]; + + /++ + Skips dropping items when the block is removed. + +/ + enum skipDrops = BlockFlags[3]; + + /++ + Indicates the block was moved (e.g., by a piston). + +/ + enum moved = BlockFlags[4]; + + /++ + Skips state replacement for redstone wires. + +/ + enum skipRedstoneWireStateReplacement = BlockFlags[5]; + + /++ + Skips the callback when a block entity is replaced. + +/ + enum skipBlockEntityReplacedCallback = BlockFlags[6]; + + /++ + Skips the callback when a block is added. + +/ + enum skipBlockAddedCallback = BlockFlags[7]; +} + +/++ +Flammability properties of a block. ++/ +struct Flammable { + /++ + + +/ + ubyte spreadChance; + + /++ + + +/ + ubyte burnChance; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + Flammable witClone() const @nogc nothrow { + Flammable clone = void; + clone.spreadChance = this.spreadChance.witClone; + clone.burnChance = this.burnChance.witClone; + return clone; + } +} + +/++ +Musical instruments used by note blocks. ++/ +enum NoteblockInstrument : ubyte { + /++ + + +/ + harp, + + /++ + + +/ + basedrum, + + /++ + + +/ + snare, + + /++ + + +/ + hat, + + /++ + + +/ + bass, + + /++ + + +/ + flute, + + /++ + + +/ + bell, + + /++ + + +/ + guitar, + + /++ + + +/ + chime, + + /++ + + +/ + xylophone, + + /++ + + +/ + ironXylophone, + + /++ + + +/ + cowBell, + + /++ + + +/ + didgeridoo, + + /++ + + +/ + bit, + + /++ + + +/ + banjo, + + /++ + + +/ + pling, + + /++ + + +/ + trumpet, + + /++ + + +/ + trumpetExposed, + + /++ + + +/ + trumpetOxidized, + + /++ + + +/ + trumpetWeathered, + + /++ + + +/ + zombie, + + /++ + + +/ + skeleton, + + /++ + + +/ + creeper, + + /++ + + +/ + dragon, + + /++ + + +/ + witherSkeleton, + + /++ + + +/ + piglin, + + /++ + + +/ + customHead, +} +/++ +Static definition of a Minecraft block type. ++/ +struct Block { + /++ + The internal numerical ID of the block type. + +/ + ushort id; + + /++ + The unique namespaced ID (e.g., "minecraft:stone"). + +/ + WitString name; + + /++ + How hard the block is to break (-1.0 for unbreakable blocks). + +/ + float hardness; + + /++ + Resistance to explosions. + +/ + float blastResistance; + + /++ + The color of this block when displayed on a map. + +/ + ubyte mapColor; + + /++ + The friction coefficient (0.6 default, 0.98 for ice). + +/ + float slipperiness; + + /++ + How much this block affects entity walk speed. + +/ + float velocityMultiplier; + + /++ + How much this block affects entity jump height. + +/ + float jumpVelocityMultiplier; + + /++ + The item ID associated with this block in inventory/drops. + +/ + ushort itemId; + + /++ + The default block state ID when placed without extra properties. + +/ + ushort defaultStateId; + + /++ + All valid state IDs belonging to this block type. + +/ + WitList!(ushort) stateIds; + + /++ + Whether this block is solid by default. + +/ + bool isSolid; + + /++ + Whether this block is considered air. + +/ + bool isAir; + + /++ + Whether this block is flammable. + +/ + bool isFlammable; + + /++ + Flammability details if flammable. + +/ + Option!(Flammable) flammable; + + void witFree() @nogc nothrow { + name.witFree; + stateIds.witFree; + } + + void witDrop() @nogc nothrow { + } + + Block witClone() const @nogc nothrow { + Block clone = void; + clone.id = this.id.witClone; + clone.name = this.name.witClone; + clone.hardness = this.hardness.witClone; + clone.blastResistance = this.blastResistance.witClone; + clone.mapColor = this.mapColor.witClone; + clone.slipperiness = this.slipperiness.witClone; + clone.velocityMultiplier = this.velocityMultiplier.witClone; + clone.jumpVelocityMultiplier = this.jumpVelocityMultiplier.witClone; + clone.itemId = this.itemId.witClone; + clone.defaultStateId = this.defaultStateId.witClone; + clone.stateIds = this.stateIds.witClone; + clone.isSolid = this.isSolid.witClone; + clone.isAir = this.isAir.witClone; + clone.isFlammable = this.isFlammable.witClone; + clone.flammable = this.flammable.witClone; + return clone; + } +} + +/++ +A simple wrapper for a block state ID. ++/ +struct BlockStateId { + /++ + + +/ + ushort id; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + BlockStateId witClone() const @nogc nothrow { + BlockStateId clone = void; + clone.id = this.id.witClone; + return clone; + } +} + +/++ +Represents an axis-aligned bounding box. ++/ +struct BoundingBox { + /++ + + +/ + Position min; + + /++ + + +/ + Position max; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + BoundingBox witClone() const @nogc nothrow { + BoundingBox clone = void; + clone.min = this.min.witClone; + clone.max = this.max.witClone; + return clone; + } +} + +/++ +Detailed information about a block's state. ++/ +struct BlockState { + /++ + The internal numerical ID of the block state. + +/ + ushort id; + + /++ + The numerical ID of the parent block type. + +/ + ushort blockId; + + /++ + The namespaced identifier of the parent block type. + +/ + WitString blockName; + + /++ + The light level emitted by this block (0-15). + +/ + ubyte luminance; + + /++ + How much light this block blocks. + +/ + ubyte opacity; + + /++ + The hardness of the block, determining mining speed. + +/ + float hardness; + + /++ + Whether this block is considered air. + +/ + bool isAir; + + /++ + Whether this block is a liquid. + +/ + bool isLiquid; + + /++ + Whether this block is a solid. + +/ + bool isSolid; + + /++ + Whether this block occupies a full cube. + +/ + bool isFullCube; + + /++ + How this block behaves when pushed by a piston. + +/ + PistonBehavior pistonBehavior; + + /++ + Whether this block receives random ticks. + +/ + bool hasRandomTicks; + + /++ + Whether this block can catch fire. + +/ + bool burnable; + + /++ + Whether a specific tool is required to mine this block and get drops. + +/ + bool toolRequired; + + /++ + Whether this block has transparency on its sides. + +/ + bool sidedTransparency; + + /++ + Whether this block can be replaced by another block (e.g., grass). + +/ + bool replaceable; + + /++ + Whether this block is considered a solid block for redstone purposes. + +/ + bool isSolidBlock; + + /++ + The numerical ID of the block entity type, if any. + +/ + ushort blockEntityType; + + /++ + The instrument used for note blocks when placed on top of this block. + +/ + NoteblockInstrument instrument; + + /++ + The collision shapes of this block. + +/ + WitList!(BoundingBox) collisionShapes; + + /++ + The outline shapes of this block. + +/ + WitList!(BoundingBox) outlineShapes; + + /++ + Whether the bottom side of the block is solid. + +/ + bool downSideSolid; + + /++ + Whether the top side of the block is solid. + +/ + bool upSideSolid; + + /++ + Whether the north side of the block is solid. + +/ + bool northSideSolid; + + /++ + Whether the south side of the block is solid. + +/ + bool southSideSolid; + + /++ + Whether the west side of the block is solid. + +/ + bool westSideSolid; + + /++ + Whether the east side of the block is solid. + +/ + bool eastSideSolid; + + /++ + Whether the center of the bottom side is solid. + +/ + bool downCenterSolid; + + /++ + Whether the center of the top side is solid. + +/ + bool upCenterSolid; + + /++ + The color of this block when displayed on a map. + +/ + ubyte mapColor; + + /++ + The block state's property key-value pairs (e.g. facing=north). + +/ + WitList!(Tuple!(WitString, WitString)) properties; + + void witFree() @nogc nothrow { + blockName.witFree; + collisionShapes.witFree; + outlineShapes.witFree; + properties.witFree; + } + + void witDrop() @nogc nothrow { + } + + BlockState witClone() const @nogc nothrow { + BlockState clone = void; + clone.id = this.id.witClone; + clone.blockId = this.blockId.witClone; + clone.blockName = this.blockName.witClone; + clone.luminance = this.luminance.witClone; + clone.opacity = this.opacity.witClone; + clone.hardness = this.hardness.witClone; + clone.isAir = this.isAir.witClone; + clone.isLiquid = this.isLiquid.witClone; + clone.isSolid = this.isSolid.witClone; + clone.isFullCube = this.isFullCube.witClone; + clone.pistonBehavior = this.pistonBehavior.witClone; + clone.hasRandomTicks = this.hasRandomTicks.witClone; + clone.burnable = this.burnable.witClone; + clone.toolRequired = this.toolRequired.witClone; + clone.sidedTransparency = this.sidedTransparency.witClone; + clone.replaceable = this.replaceable.witClone; + clone.isSolidBlock = this.isSolidBlock.witClone; + clone.blockEntityType = this.blockEntityType.witClone; + clone.instrument = this.instrument.witClone; + clone.collisionShapes = this.collisionShapes.witClone; + clone.outlineShapes = this.outlineShapes.witClone; + clone.downSideSolid = this.downSideSolid.witClone; + clone.upSideSolid = this.upSideSolid.witClone; + clone.northSideSolid = this.northSideSolid.witClone; + clone.southSideSolid = this.southSideSolid.witClone; + clone.westSideSolid = this.westSideSolid.witClone; + clone.eastSideSolid = this.eastSideSolid.witClone; + clone.downCenterSolid = this.downCenterSolid.witClone; + clone.upCenterSolid = this.upCenterSolid.witClone; + clone.mapColor = this.mapColor.witClone; + clone.properties = this.properties.witClone; + return clone; + } +} + +/++ +Represents the configured shared spawn location for a world. ++/ +struct WorldSpawnLocation { + /++ + The block position of the shared world spawn. + +/ + BlockPos pos; + + /++ + The yaw players should face when spawning here. + +/ + float yaw; + + /++ + The pitch players should use when spawning here. + +/ + float pitch; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + WorldSpawnLocation witClone() const @nogc nothrow { + WorldSpawnLocation clone = void; + clone.pos = this.pos.witClone; + clone.yaw = this.yaw.witClone; + clone.pitch = this.pitch.witClone; + return clone; + } +} + +/++ +Represents a cardinal direction or block face. ++/ +enum BlockDirection : ubyte { + /++ + + +/ + down, + + /++ + + +/ + up, + + /++ + + +/ + north, + + /++ + + +/ + south, + + /++ + + +/ + west, + + /++ + + +/ + east, +} +/++ +Specialized data for shulker entities. ++/ +struct ShulkerData { + /++ + + +/ + BlockDirection attachedFace; + + /++ + + +/ + ubyte peekAmount; + + /++ + + +/ + Option!(DyeColor) color; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + ShulkerData witClone() const @nogc nothrow { + ShulkerData clone = void; + clone.attachedFace = this.attachedFace.witClone; + clone.peekAmount = this.peekAmount.witClone; + clone.color = this.color.witClone; + return clone; + } +} + +/++ +Tagged variant holding specialized data for specific mob types. ++/ +struct MobData { + mixin WitVariant!( + SheepData, // sheep + WolfData, // wolf + CatData, // cat + VillagerData, // villager + CreeperData, // creeper + SlimeData, // slime + EndermanData, // enderman + IronGolemData, // ironGolem + FoxData, // fox + AgeableData, // ageable + ZombieData, // zombie + ShulkerData, // shulker + void, // generic + ); + +public: + enum Tag : ubyte { + /++ + + +/ + sheep, + + /++ + + +/ + wolf, + + /++ + + +/ + cat, + + /++ + + +/ + villager, + + /++ + + +/ + creeper, + + /++ + + +/ + slime, + + /++ + + +/ + enderman, + + /++ + + +/ + ironGolem, + + /++ + + +/ + fox, + + /++ + + +/ + ageable, + + /++ + + +/ + zombie, + + /++ + + +/ + shulker, + + /++ + + +/ + generic, + } + pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag; + + /++ + + +/ + alias sheep = _create!(Tag.sheep); + /// ditto + pragma(inline, true) bool isSheep() const => _tag == Tag.sheep; + ///ditto + alias getSheep = _get!(Tag.sheep); + + /++ + + +/ + alias wolf = _create!(Tag.wolf); + /// ditto + pragma(inline, true) bool isWolf() const => _tag == Tag.wolf; + ///ditto + alias getWolf = _get!(Tag.wolf); + + /++ + + +/ + alias cat = _create!(Tag.cat); + /// ditto + pragma(inline, true) bool isCat() const => _tag == Tag.cat; + ///ditto + alias getCat = _get!(Tag.cat); + + /++ + + +/ + alias villager = _create!(Tag.villager); + /// ditto + pragma(inline, true) bool isVillager() const => _tag == Tag.villager; + ///ditto + alias getVillager = _get!(Tag.villager); + + /++ + + +/ + alias creeper = _create!(Tag.creeper); + /// ditto + pragma(inline, true) bool isCreeper() const => _tag == Tag.creeper; + ///ditto + alias getCreeper = _get!(Tag.creeper); + + /++ + + +/ + alias slime = _create!(Tag.slime); + /// ditto + pragma(inline, true) bool isSlime() const => _tag == Tag.slime; + ///ditto + alias getSlime = _get!(Tag.slime); + + /++ + + +/ + alias enderman = _create!(Tag.enderman); + /// ditto + pragma(inline, true) bool isEnderman() const => _tag == Tag.enderman; + ///ditto + alias getEnderman = _get!(Tag.enderman); + + /++ + + +/ + alias ironGolem = _create!(Tag.ironGolem); + /// ditto + pragma(inline, true) bool isIronGolem() const => _tag == Tag.ironGolem; + ///ditto + alias getIronGolem = _get!(Tag.ironGolem); + + /++ + + +/ + alias fox = _create!(Tag.fox); + /// ditto + pragma(inline, true) bool isFox() const => _tag == Tag.fox; + ///ditto + alias getFox = _get!(Tag.fox); + + /++ + + +/ + alias ageable = _create!(Tag.ageable); + /// ditto + pragma(inline, true) bool isAgeable() const => _tag == Tag.ageable; + ///ditto + alias getAgeable = _get!(Tag.ageable); + + /++ + + +/ + alias zombie = _create!(Tag.zombie); + /// ditto + pragma(inline, true) bool isZombie() const => _tag == Tag.zombie; + ///ditto + alias getZombie = _get!(Tag.zombie); + + /++ + + +/ + alias shulker = _create!(Tag.shulker); + /// ditto + pragma(inline, true) bool isShulker() const => _tag == Tag.shulker; + ///ditto + alias getShulker = _get!(Tag.shulker); + + /++ + + +/ + alias generic = _create!(Tag.generic); + /// ditto + pragma(inline, true) bool isGeneric() const => _tag == Tag.generic; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + MobData witClone() const @nogc nothrow { + final switch (_tag) { + case Tag.sheep: return _create!(Tag.sheep)(this._get!(Tag.sheep).witClone); break; + case Tag.wolf: return _create!(Tag.wolf)(this._get!(Tag.wolf).witClone); break; + case Tag.cat: return _create!(Tag.cat)(this._get!(Tag.cat).witClone); break; + case Tag.villager: return _create!(Tag.villager)(this._get!(Tag.villager).witClone); break; + case Tag.creeper: return _create!(Tag.creeper)(this._get!(Tag.creeper).witClone); break; + case Tag.slime: return _create!(Tag.slime)(this._get!(Tag.slime).witClone); break; + case Tag.enderman: return _create!(Tag.enderman)(this._get!(Tag.enderman).witClone); break; + case Tag.ironGolem: return _create!(Tag.ironGolem)(this._get!(Tag.ironGolem).witClone); break; + case Tag.fox: return _create!(Tag.fox)(this._get!(Tag.fox).witClone); break; + case Tag.ageable: return _create!(Tag.ageable)(this._get!(Tag.ageable).witClone); break; + case Tag.zombie: return _create!(Tag.zombie)(this._get!(Tag.zombie).witClone); break; + case Tag.shulker: return _create!(Tag.shulker)(this._get!(Tag.shulker).witClone); break; + case Tag.generic: return _create!(Tag.generic); break; + } + } +} + +/++ +Result of a raycast operation. ++/ +struct RaycastResult { + /++ + The block position that was hit. + +/ + BlockPos pos; + + /++ + The face of the block that was hit. + +/ + BlockDirection face; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + RaycastResult witClone() const @nogc nothrow { + RaycastResult clone = void; + clone.pos = this.pos.witClone; + clone.face = this.face.witClone; + return clone; + } +} + +/++ +Detailed result of a block ray-trace operation. ++/ +struct RayTraceBlockResult { + /++ + The block position that was hit. + +/ + BlockPos pos; + + /++ + The face of the block that was hit. + +/ + BlockDirection face; + + /++ + The exact hit coordinates in world space. + +/ + Position hitPos; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + } + + RayTraceBlockResult witClone() const @nogc nothrow { + RayTraceBlockResult clone = void; + clone.pos = this.pos.witClone; + clone.face = this.face.witClone; + clone.hitPos = this.hitPos.witClone; + return clone; + } +} + +/++ +Generation phase for custom chunk generation. ++/ +enum GenerationPhase : ubyte { + /++ + + +/ + biomes, + + /++ + + +/ + noise, + + /++ + + +/ + surface, + + /++ + + +/ + features, +} +/++ +A block's registry name and its property key-value pairs for a state ID. ++/ +struct BlockStateInfo { + /++ + + +/ + WitString name; + + /++ + + +/ + WitList!(Tuple!(WitString, WitString)) properties; + + void witFree() @nogc nothrow { + name.witFree; + properties.witFree; + } + + void witDrop() @nogc nothrow { + } + + BlockStateInfo witClone() const @nogc nothrow { + BlockStateInfo clone = void; + clone.name = this.name.witClone; + clone.properties = this.properties.witClone; + return clone; + } +} diff --git a/src/wit/pumpkin/plugin/world/imports.d b/src/wit/pumpkin/plugin/world/imports.d new file mode 100644 index 0000000..8e4494e --- /dev/null +++ b/src/wit/pumpkin/plugin/world/imports.d @@ -0,0 +1,6627 @@ +/++ + ++/ +module wit.pumpkin.plugin.world.imports; + + +import wit.common; + +public import wit.pumpkin.plugin.world.common; + +static import wit.pumpkin.plugin.attributes.imports; +static import wit.pumpkin.plugin.biomes.imports; +static import wit.pumpkin.plugin.common.imports; +static import wit.pumpkin.plugin.damage_types.imports; +static import wit.pumpkin.plugin.entity_types.imports; +static import wit.pumpkin.plugin.game_rules.imports; +static import wit.pumpkin.plugin.particles.imports; +static import wit.pumpkin.plugin.sounds.imports; +static import wit.pumpkin.plugin.text.imports; +static import wit.pumpkin.plugin.item_stack.imports; +static import wit.pumpkin.plugin.block_entity.imports; +static import wit.pumpkin.plugin.scoreboard.imports; +static import wit.pumpkin.plugin.uuid.imports; + +package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link(); + +/++ + ++/ +alias BlockEntity = wit.pumpkin.plugin.block_entity.imports.BlockEntity; + +/++ + ++/ +alias CommandBlockEntity = wit.pumpkin.plugin.block_entity.imports.CommandBlockEntity; + +/++ + ++/ +alias BlockEntityType = wit.pumpkin.plugin.block_entity.imports.BlockEntityType; + +/++ + ++/ +alias TextComponent = wit.pumpkin.plugin.text.imports.TextComponent; + +/++ + ++/ +alias Scoreboard = wit.pumpkin.plugin.scoreboard.imports.Scoreboard; + +/++ + ++/ +alias ItemStack = wit.pumpkin.plugin.item_stack.imports.ItemStack; + +/++ + ++/ +struct Entity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/world@0.1.0", "[resource-drop]entity") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:resource_drop:entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + + +/ + uint getId() @trusted nothrow { + auto _ret = __import_getId(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-id") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_id") + static private extern(C) uint __import_getId(uint) nothrow; + + /++ + + +/ + Uuid getUuid() @trusted nothrow { + align(8) void[16] _retArea = void; + __import_getUuid(this.__handle, _retArea.ptr); + wit.pumpkin.plugin.uuid.imports.Uuid _record0 = { + high: *(cast(ulong*)(_retArea.ptr + 0)), + low: *(cast(ulong*)(_retArea.ptr + 8)), + }; + auto _flush1 = _record0; + return _flush1; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-uuid") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_uuid") + static private extern(C) void __import_getUuid(uint, void*) nothrow; + + /++ + + +/ + EntityType getType() @trusted nothrow { + auto _ret = __import_getType(this.__handle); + return cast(wit.pumpkin.plugin.entity_types.imports.EntityType)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-type") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_type") + static private extern(C) uint __import_getType(uint) nothrow; + + /++ + + +/ + Position getPosition() @trusted nothrow { + align(8) void[24] _retArea = void; + __import_getPosition(this.__handle, _retArea.ptr); + auto _tuple0 = wit.pumpkin.plugin.common.imports.Position( + *(cast(double*)(_retArea.ptr + 0)), + *(cast(double*)(_retArea.ptr + 8)), + *(cast(double*)(_retArea.ptr + 16)), + ); + auto _flush1 = _tuple0; + return _flush1; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-position") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_position") + static private extern(C) void __import_getPosition(uint, void*) nothrow; + + /++ + + +/ + World getWorld() @trusted nothrow { + auto _ret = __import_getWorld(this.__handle); + auto _handle0 = World(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-world") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_world") + static private extern(C) uint __import_getWorld(uint) nothrow; + + /++ + + +/ + float getYaw() @trusted nothrow { + auto _ret = __import_getYaw(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-yaw") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_yaw") + static private extern(C) float __import_getYaw(uint) nothrow; + + /++ + + +/ + float getPitch() @trusted nothrow { + auto _ret = __import_getPitch(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-pitch") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_pitch") + static private extern(C) float __import_getPitch(uint) nothrow; + + /++ + + +/ + float getHeadYaw() @trusted nothrow { + auto _ret = __import_getHeadYaw(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-head-yaw") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_head_yaw") + static private extern(C) float __import_getHeadYaw(uint) nothrow; + + /++ + + +/ + void teleport(in Position pos, World worldRef) @trusted nothrow { + __import_teleport(this.__handle, pos[0], pos[1], pos[2], worldRef.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.teleport") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.teleport") + static private extern(C) void __import_teleport(uint, double, double, double, uint) nothrow; + + /++ + + +/ + void setVelocity(in Position velocity) @trusted nothrow { + __import_setVelocity(this.__handle, velocity[0], velocity[1], velocity[2]); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.set-velocity") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.set_velocity") + static private extern(C) void __import_setVelocity(uint, double, double, double) nothrow; + + /++ + + +/ + Position getVelocity() @trusted nothrow { + align(8) void[24] _retArea = void; + __import_getVelocity(this.__handle, _retArea.ptr); + auto _tuple0 = wit.pumpkin.plugin.common.imports.Position( + *(cast(double*)(_retArea.ptr + 0)), + *(cast(double*)(_retArea.ptr + 8)), + *(cast(double*)(_retArea.ptr + 16)), + ); + auto _flush1 = _tuple0; + return _flush1; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-velocity") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_velocity") + static private extern(C) void __import_getVelocity(uint, void*) nothrow; + + /++ + + +/ + EntityPose getPose() @trusted nothrow { + auto _ret = __import_getPose(this.__handle); + return cast(wit.pumpkin.plugin.common.imports.EntityPose)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-pose") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_pose") + static private extern(C) uint __import_getPose(uint) nothrow; + + /++ + + +/ + TextComponent getName() @trusted nothrow { + auto _ret = __import_getName(this.__handle); + auto _handle0 = TextComponent(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-name") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_name") + static private extern(C) uint __import_getName(uint) nothrow; + + /++ + + +/ + void setCustomName(TextComponent name) @trusted nothrow { + __import_setCustomName(this.__handle, name.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.set-custom-name") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.set_custom_name") + static private extern(C) void __import_setCustomName(uint, uint) nothrow; + + /++ + + +/ + Option!(TextComponent) getCustomName() @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getCustomName(this.__handle, _retArea.ptr); + Option!(TextComponent) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = TextComponent(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(TextComponent).makeSome(_handle2); + } else { + _option3 = Option!(TextComponent).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-custom-name") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_custom_name") + static private extern(C) void __import_getCustomName(uint, void*) nothrow; + + /++ + + +/ + void setCustomNameVisible(bool visible) @trusted nothrow { + __import_setCustomNameVisible(this.__handle, cast(uint)(visible)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.set-custom-name-visible") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.set_custom_name_visible") + static private extern(C) void __import_setCustomNameVisible(uint, uint) nothrow; + + /++ + + +/ + bool isCustomNameVisible() @trusted nothrow { + auto _ret = __import_isCustomNameVisible(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.is-custom-name-visible") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.is_custom_name_visible") + static private extern(C) uint __import_isCustomNameVisible(uint) nothrow; + + /++ + + +/ + bool isInvulnerable() @trusted nothrow { + auto _ret = __import_isInvulnerable(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.is-invulnerable") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.is_invulnerable") + static private extern(C) uint __import_isInvulnerable(uint) nothrow; + + /++ + + +/ + void setInvulnerable(bool invulnerable) @trusted nothrow { + __import_setInvulnerable(this.__handle, cast(uint)(invulnerable)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.set-invulnerable") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.set_invulnerable") + static private extern(C) void __import_setInvulnerable(uint, uint) nothrow; + + /++ + + +/ + int getFireTicks() @trusted nothrow { + auto _ret = __import_getFireTicks(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-fire-ticks") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_fire_ticks") + static private extern(C) uint __import_getFireTicks(uint) nothrow; + + /++ + + +/ + void setFireTicks(int ticks) @trusted nothrow { + __import_setFireTicks(this.__handle, cast(uint)(ticks)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.set-fire-ticks") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.set_fire_ticks") + static private extern(C) void __import_setFireTicks(uint, uint) nothrow; + + /++ + + +/ + float getFallDistance() @trusted nothrow { + auto _ret = __import_getFallDistance(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-fall-distance") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_fall_distance") + static private extern(C) float __import_getFallDistance(uint) nothrow; + + /++ + + +/ + void setFallDistance(float distance) @trusted nothrow { + __import_setFallDistance(this.__handle, distance); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.set-fall-distance") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.set_fall_distance") + static private extern(C) void __import_setFallDistance(uint, float) nothrow; + + /++ + + +/ + int getTicksLived() @trusted nothrow { + auto _ret = __import_getTicksLived(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-ticks-lived") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_ticks_lived") + static private extern(C) uint __import_getTicksLived(uint) nothrow; + + /++ + + +/ + void setTicksLived(int ticks) @trusted nothrow { + __import_setTicksLived(this.__handle, cast(uint)(ticks)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.set-ticks-lived") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.set_ticks_lived") + static private extern(C) void __import_setTicksLived(uint, uint) nothrow; + + /++ + + +/ + bool isSneaking() @trusted nothrow { + auto _ret = __import_isSneaking(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.is-sneaking") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.is_sneaking") + static private extern(C) uint __import_isSneaking(uint) nothrow; + + /++ + + +/ + void setSneaking(bool sneaking) @trusted nothrow { + __import_setSneaking(this.__handle, cast(uint)(sneaking)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.set-sneaking") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.set_sneaking") + static private extern(C) void __import_setSneaking(uint, uint) nothrow; + + /++ + + +/ + bool isSprinting() @trusted nothrow { + auto _ret = __import_isSprinting(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.is-sprinting") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.is_sprinting") + static private extern(C) uint __import_isSprinting(uint) nothrow; + + /++ + + +/ + void setSprinting(bool sprinting) @trusted nothrow { + __import_setSprinting(this.__handle, cast(uint)(sprinting)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.set-sprinting") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.set_sprinting") + static private extern(C) void __import_setSprinting(uint, uint) nothrow; + + /++ + + +/ + bool isSwimming() @trusted nothrow { + auto _ret = __import_isSwimming(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.is-swimming") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.is_swimming") + static private extern(C) uint __import_isSwimming(uint) nothrow; + + /++ + + +/ + void setSwimming(bool swimming) @trusted nothrow { + __import_setSwimming(this.__handle, cast(uint)(swimming)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.set-swimming") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.set_swimming") + static private extern(C) void __import_setSwimming(uint, uint) nothrow; + + /++ + + +/ + bool isInvisible() @trusted nothrow { + auto _ret = __import_isInvisible(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.is-invisible") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.is_invisible") + static private extern(C) uint __import_isInvisible(uint) nothrow; + + /++ + + +/ + void setInvisible(bool invisible) @trusted nothrow { + __import_setInvisible(this.__handle, cast(uint)(invisible)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.set-invisible") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.set_invisible") + static private extern(C) void __import_setInvisible(uint, uint) nothrow; + + /++ + + +/ + bool isGlowing() @trusted nothrow { + auto _ret = __import_isGlowing(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.is-glowing") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.is_glowing") + static private extern(C) uint __import_isGlowing(uint) nothrow; + + /++ + + +/ + void setGlowing(bool glowing) @trusted nothrow { + __import_setGlowing(this.__handle, cast(uint)(glowing)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.set-glowing") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.set_glowing") + static private extern(C) void __import_setGlowing(uint, uint) nothrow; + + /++ + + +/ + bool isFallFlying() @trusted nothrow { + auto _ret = __import_isFallFlying(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.is-fall-flying") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.is_fall_flying") + static private extern(C) uint __import_isFallFlying(uint) nothrow; + + /++ + + +/ + void setFallFlying(bool fallFlying) @trusted nothrow { + __import_setFallFlying(this.__handle, cast(uint)(fallFlying)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.set-fall-flying") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.set_fall_flying") + static private extern(C) void __import_setFallFlying(uint, uint) nothrow; + + /++ + + +/ + bool isSilent() @trusted nothrow { + auto _ret = __import_isSilent(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.is-silent") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.is_silent") + static private extern(C) uint __import_isSilent(uint) nothrow; + + /++ + + +/ + void setSilent(bool silent) @trusted nothrow { + __import_setSilent(this.__handle, cast(uint)(silent)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.set-silent") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.set_silent") + static private extern(C) void __import_setSilent(uint, uint) nothrow; + + /++ + + +/ + bool hasGravity() @trusted nothrow { + auto _ret = __import_hasGravity(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.has-gravity") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.has_gravity") + static private extern(C) uint __import_hasGravity(uint) nothrow; + + /++ + + +/ + void setHasGravity(bool gravity) @trusted nothrow { + __import_setHasGravity(this.__handle, cast(uint)(gravity)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.set-has-gravity") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.set_has_gravity") + static private extern(C) void __import_setHasGravity(uint, uint) nothrow; + + /++ + + +/ + float getWidth() @trusted nothrow { + auto _ret = __import_getWidth(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-width") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_width") + static private extern(C) float __import_getWidth(uint) nothrow; + + /++ + + +/ + float getHeight() @trusted nothrow { + auto _ret = __import_getHeight(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-height") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_height") + static private extern(C) float __import_getHeight(uint) nothrow; + + /++ + + +/ + void setRotation(float yaw, float pitch) @trusted nothrow { + __import_setRotation(this.__handle, yaw, pitch); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.set-rotation") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.set_rotation") + static private extern(C) void __import_setRotation(uint, float, float) nothrow; + + /++ + + +/ + bool isOnGround() @trusted nothrow { + auto _ret = __import_isOnGround(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.is-on-ground") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.is_on_ground") + static private extern(C) uint __import_isOnGround(uint) nothrow; + + /++ + + +/ + bool isOnFire() @trusted nothrow { + auto _ret = __import_isOnFire(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.is-on-fire") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.is_on_fire") + static private extern(C) uint __import_isOnFire(uint) nothrow; + + /++ + + +/ + void setOnFire(bool onFire) @trusted nothrow { + __import_setOnFire(this.__handle, cast(uint)(onFire)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.set-on-fire") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.set_on_fire") + static private extern(C) void __import_setOnFire(uint, uint) nothrow; + + /++ + + +/ + bool hasVisualFire() @trusted nothrow { + auto _ret = __import_hasVisualFire(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.has-visual-fire") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.has_visual_fire") + static private extern(C) uint __import_hasVisualFire(uint) nothrow; + + /++ + + +/ + void setVisualFire(bool visualFire) @trusted nothrow { + __import_setVisualFire(this.__handle, cast(uint)(visualFire)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.set-visual-fire") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.set_visual_fire") + static private extern(C) void __import_setVisualFire(uint, uint) nothrow; + + /++ + + +/ + uint getPortalCooldown() @trusted nothrow { + auto _ret = __import_getPortalCooldown(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-portal-cooldown") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_portal_cooldown") + static private extern(C) uint __import_getPortalCooldown(uint) nothrow; + + /++ + + +/ + void setPortalCooldown(uint cooldown) @trusted nothrow { + __import_setPortalCooldown(this.__handle, cooldown); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.set-portal-cooldown") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.set_portal_cooldown") + static private extern(C) void __import_setPortalCooldown(uint, uint) nothrow; + + /++ + + +/ + int getRemainingAir() @trusted nothrow { + auto _ret = __import_getRemainingAir(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-remaining-air") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_remaining_air") + static private extern(C) uint __import_getRemainingAir(uint) nothrow; + + /++ + + +/ + void setRemainingAir(int air) @trusted nothrow { + __import_setRemainingAir(this.__handle, cast(uint)(air)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.set-remaining-air") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.set_remaining_air") + static private extern(C) void __import_setRemainingAir(uint, uint) nothrow; + + /++ + + +/ + int getMaxAir() @trusted nothrow { + auto _ret = __import_getMaxAir(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-max-air") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_max_air") + static private extern(C) uint __import_getMaxAir(uint) nothrow; + + /++ + + +/ + float getEyeHeight() @trusted nothrow { + auto _ret = __import_getEyeHeight(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-eye-height") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_eye_height") + static private extern(C) float __import_getEyeHeight(uint) nothrow; + + /++ + + +/ + Position getEyePosition() @trusted nothrow { + align(8) void[24] _retArea = void; + __import_getEyePosition(this.__handle, _retArea.ptr); + auto _tuple0 = wit.pumpkin.plugin.common.imports.Position( + *(cast(double*)(_retArea.ptr + 0)), + *(cast(double*)(_retArea.ptr + 8)), + *(cast(double*)(_retArea.ptr + 16)), + ); + auto _flush1 = _tuple0; + return _flush1; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-eye-position") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_eye_position") + static private extern(C) void __import_getEyePosition(uint, void*) nothrow; + + /++ + + +/ + WitList!(Entity) getNearbyEntities(double x, double y, double z) @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getNearbyEntities(this.__handle, x, y, z, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(Entity*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitList!(Entity)(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-nearby-entities") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_nearby_entities") + static private extern(C) void __import_getNearbyEntities(uint, double, double, double, void*) nothrow; + + /++ + + +/ + Option!(Entity) getVehicle() @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getVehicle(this.__handle, _retArea.ptr); + Option!(Entity) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = Entity(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(Entity).makeSome(_handle2); + } else { + _option3 = Option!(Entity).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-vehicle") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_vehicle") + static private extern(C) void __import_getVehicle(uint, void*) nothrow; + + /++ + + +/ + void setVehicle(in Option!(Entity) vehicle) @trusted nothrow { + uint _option4 = void; + uint _option5 = void; + if (vehicle.isSome) { + ref _payload3 = vehicle.unwrap(); + _option4 = 1; + _option5 = _payload3.__handle; + } else { + _option4 = 0; + _option5 = 0; + } + __import_setVehicle(this.__handle, _option4, _option5); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.set-vehicle") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.set_vehicle") + static private extern(C) void __import_setVehicle(uint, uint, uint) nothrow; + + /++ + + +/ + WitList!(Entity) getPassengers() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getPassengers(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(Entity*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitList!(Entity)(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-passengers") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_passengers") + static private extern(C) void __import_getPassengers(uint, void*) nothrow; + + /++ + + +/ + void addPassenger(Entity passenger) @trusted nothrow { + __import_addPassenger(this.__handle, passenger.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.add-passenger") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.add_passenger") + static private extern(C) void __import_addPassenger(uint, uint) nothrow; + + /++ + + +/ + void removePassenger(Entity passenger) @trusted nothrow { + __import_removePassenger(this.__handle, passenger.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.remove-passenger") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.remove_passenger") + static private extern(C) void __import_removePassenger(uint, uint) nothrow; + + /++ + + +/ + void ejectPassengers() @trusted nothrow { + __import_ejectPassengers(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.eject-passengers") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.eject_passengers") + static private extern(C) void __import_ejectPassengers(uint) nothrow; + + /++ + + +/ + BoundingBox getBoundingBox() @trusted nothrow { + align(8) void[48] _retArea = void; + __import_getBoundingBox(this.__handle, _retArea.ptr); + auto _tuple0 = wit.pumpkin.plugin.common.imports.Position( + *(cast(double*)(_retArea.ptr + 0)), + *(cast(double*)(_retArea.ptr + 8)), + *(cast(double*)(_retArea.ptr + 16)), + ); + auto _tuple1 = wit.pumpkin.plugin.common.imports.Position( + *(cast(double*)(_retArea.ptr + 24)), + *(cast(double*)(_retArea.ptr + 32)), + *(cast(double*)(_retArea.ptr + 40)), + ); + BoundingBox _record2 = { + min: _tuple0, + max: _tuple1, + }; + auto _flush3 = _record2; + return _flush3; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-bounding-box") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_bounding_box") + static private extern(C) void __import_getBoundingBox(uint, void*) nothrow; + + /++ + + +/ + bool isInWater() @trusted nothrow { + auto _ret = __import_isInWater(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.is-in-water") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.is_in_water") + static private extern(C) uint __import_isInWater(uint) nothrow; + + /++ + + +/ + bool isInLava() @trusted nothrow { + auto _ret = __import_isInLava(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.is-in-lava") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.is_in_lava") + static private extern(C) uint __import_isInLava(uint) nothrow; + + /++ + + +/ + void remove() @trusted nothrow { + __import_remove(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.remove") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.remove") + static private extern(C) void __import_remove(uint) nothrow; + + /++ + Performs a raycast from the entity's eye position in its looking direction. + +/ + Option!(RaycastResult) raycast(double maxDistance, bool fluidHandling) @trusted nothrow { + align(4) void[20] _retArea = void; + __import_raycast(this.__handle, maxDistance, cast(uint)(fluidHandling), _retArea.ptr); + Option!(RaycastResult) _option4 = void; + bool _isSome4 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome4) { + wit.pumpkin.plugin.common.imports.BlockPos _record2 = { + x: cast(int)(*(cast(uint*)(_retArea.ptr + 4))), + y: cast(int)(*(cast(uint*)(_retArea.ptr + 8))), + z: cast(int)(*(cast(uint*)(_retArea.ptr + 12))), + }; + RaycastResult _record3 = { + pos: _record2, + face: cast(BlockDirection)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 16)))), + }; + + _option4 = Option!(RaycastResult).makeSome(_record3); + } else { + _option4 = Option!(RaycastResult).makeNone; + } + auto _flush5 = _option4; + return _flush5; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.raycast") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.raycast") + static private extern(C) void __import_raycast(uint, double, uint, void*) nothrow; + + /++ + Performs a ray-trace from the entity's eye position in its looking direction to find the targeted block. + +/ + Option!(RayTraceBlockResult) rayTraceBlock(double maxDistance, bool includeFluids) @trusted nothrow { + align(8) void[48] _retArea = void; + __import_rayTraceBlock(this.__handle, maxDistance, cast(uint)(includeFluids), _retArea.ptr); + Option!(RayTraceBlockResult) _option5 = void; + bool _isSome5 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome5) { + wit.pumpkin.plugin.common.imports.BlockPos _record2 = { + x: cast(int)(*(cast(uint*)(_retArea.ptr + 8))), + y: cast(int)(*(cast(uint*)(_retArea.ptr + 12))), + z: cast(int)(*(cast(uint*)(_retArea.ptr + 16))), + }; + auto _tuple3 = wit.pumpkin.plugin.common.imports.Position( + *(cast(double*)(_retArea.ptr + 24)), + *(cast(double*)(_retArea.ptr + 32)), + *(cast(double*)(_retArea.ptr + 40)), + ); + RayTraceBlockResult _record4 = { + pos: _record2, + face: cast(BlockDirection)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 20)))), + hitPos: _tuple3, + }; + + _option5 = Option!(RayTraceBlockResult).makeSome(_record4); + } else { + _option5 = Option!(RayTraceBlockResult).makeNone; + } + auto _flush6 = _option5; + return _flush6; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.ray-trace-block") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.ray_trace_block") + static private extern(C) void __import_rayTraceBlock(uint, double, uint, void*) nothrow; + + /++ + Performs a ray-trace from the entity's eye position in its looking direction to find the targeted entity. + +/ + Option!(RayTraceEntityResult) rayTraceEntity(double maxDistance) @trusted nothrow { + align(8) void[48] _retArea = void; + __import_rayTraceEntity(this.__handle, maxDistance, _retArea.ptr); + Option!(RayTraceEntityResult) _option5 = void; + bool _isSome5 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome5) { + auto _handle2 = Entity(*(cast(uint*)(_retArea.ptr + 8))); + auto _tuple3 = wit.pumpkin.plugin.common.imports.Position( + *(cast(double*)(_retArea.ptr + 16)), + *(cast(double*)(_retArea.ptr + 24)), + *(cast(double*)(_retArea.ptr + 32)), + ); + RayTraceEntityResult _record4 = { + entity: _handle2, + hitPos: _tuple3, + distance: *(cast(double*)(_retArea.ptr + 40)), + }; + + _option5 = Option!(RayTraceEntityResult).makeSome(_record4); + } else { + _option5 = Option!(RayTraceEntityResult).makeNone; + } + auto _flush6 = _option5; + return _flush6; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.ray-trace-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.ray_trace_entity") + static private extern(C) void __import_rayTraceEntity(uint, double, void*) nothrow; + + /++ + Returns the entity currently targeted in the looking direction within the specified distance. + +/ + Option!(Entity) getTargetEntity(double maxDistance) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getTargetEntity(this.__handle, maxDistance, _retArea.ptr); + Option!(Entity) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = Entity(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(Entity).makeSome(_handle2); + } else { + _option3 = Option!(Entity).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-target-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_target_entity") + static private extern(C) void __import_getTargetEntity(uint, double, void*) nothrow; + + /++ + Sets a namespaced custom data value on this entity. + +/ + void setCustomData(in WitString namespace, in WitString key, in NbtTree value) @trusted nothrow { + wit.common.DeallocateBuffer deallocate; + auto _listSrc28 = value.tags; + auto _list28 = _listSrc28.length ? wit.common.malloc(_listSrc28.length * ((8+2*size_t.sizeof))) : null; + assert(!_listSrc28.length || _list28); + if (_listSrc28.length) deallocate ~= _list28; + foreach (_elem0_idx, ref _elem0; _listSrc28) { + auto _base0 = _list28 + _elem0_idx * ((8+2*size_t.sizeof)); + alias _Tag27 = wit.pumpkin.plugin.common.imports.NbtTag.Tag; + final switch (_elem0.tag) { + case _Tag27.byte_: { + const ref byte _payload2 = _elem0.getByte(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(0); + *cast(ubyte*)(_base0 + 8) = cast(ubyte)(cast(uint)(_payload2)); + break; + } + case _Tag27.short_: { + const ref short _payload4 = _elem0.getShort(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(1); + *cast(ushort*)(_base0 + 8) = cast(ushort)(cast(uint)(_payload4)); + break; + } + case _Tag27.int_: { + const ref int _payload6 = _elem0.getInt(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(2); + *cast(uint*)(_base0 + 8) = cast(uint)(cast(uint)(_payload6)); + break; + } + case _Tag27.long_: { + const ref long _payload8 = _elem0.getLong(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(3); + *cast(ulong*)(_base0 + 8) = cast(ulong)(cast(ulong)(_payload8)); + break; + } + case _Tag27.float_: { + const ref float _payload10 = _elem0.getFloat(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(4); + *cast(float*)(_base0 + 8) = cast(float)(_payload10); + break; + } + case _Tag27.double_: { + const ref double _payload12 = _elem0.getDouble(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(5); + *cast(double*)(_base0 + 8) = cast(double)(_payload12); + break; + } + case _Tag27.byteArray: { + const ref WitList!(byte) _payload14 = _elem0.getByteArray(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(6); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload14.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload14.ptr)); + break; + } + case _Tag27.stringTag: { + const ref WitString _payload16 = _elem0.getStringTag(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(7); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload16.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload16.ptr)); + break; + } + case _Tag27.listTag: { + const ref WitList!(uint) _payload18 = _elem0.getListTag(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(8); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload18.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload18.ptr)); + break; + } + case _Tag27.compound: { + const ref WitList!(wit.pumpkin.plugin.common.imports.NbtEntry) _payload20 = _elem0.getCompound(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(9); + auto _listSrc22 = _payload20; + auto _list22 = _listSrc22.length ? wit.common.malloc(_listSrc22.length * ((3*size_t.sizeof))) : null; + assert(!_listSrc22.length || _list22); + if (_listSrc22.length) deallocate ~= _list22; + foreach (_elem21_idx, ref _elem21; _listSrc22) { + auto _base21 = _list22 + _elem21_idx * ((3*size_t.sizeof)); + *cast(size_t*)(_base21 + size_t.sizeof) = cast(size_t)(_elem21.key.length); + *cast(void**)(_base21 + 0) = cast(void*)(cast(void*)(_elem21.key.ptr)); + *cast(uint*)(_base21 + (2*size_t.sizeof)) = cast(uint)(_elem21.value); + + } + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload20.length); + *cast(void**)(_base0 + 8) = cast(void*)(_list22); + break; + } + case _Tag27.intArray: { + const ref WitList!(int) _payload24 = _elem0.getIntArray(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(10); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload24.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload24.ptr)); + break; + } + case _Tag27.longArray: { + const ref WitList!(long) _payload26 = _elem0.getLongArray(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(11); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload26.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload26.ptr)); + break; + } + } + + } + __import_setCustomData(this.__handle, cast(void*)(namespace.ptr), namespace.length, cast(void*)(key.ptr), key.length, value.root, _list28, value.tags.length); + deallocate.purge(); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.set-custom-data") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.set_custom_data") + static private extern(C) void __import_setCustomData(uint, void*, size_t, void*, size_t, uint, void*, size_t) nothrow; + + /++ + Returns a namespaced custom data value from this entity, if set. + +/ + Option!(NbtTree) getCustomData(in WitString namespace, in WitString key) @trusted nothrow { + align(size_t.sizeof) void[(4*size_t.sizeof)] _retArea = void; + __import_getCustomData(this.__handle, cast(void*)(namespace.ptr), namespace.length, cast(void*)(key.ptr), key.length, _retArea.ptr); + Option!(NbtTree) _option47 = void; + bool _isSome47 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome47) { + auto _listSrcPtr44 = *(cast(void**)(_retArea.ptr + (2*size_t.sizeof))); + auto _listLen44 = *(cast(size_t*)(_retArea.ptr + (3*size_t.sizeof))); + auto _list44 = _listLen44 ? wit.common.mallocSlice!(wit.pumpkin.plugin.common.imports.NbtTag)(_listLen44) : []; + assert(!_listLen44 || _list44.ptr); + foreach (_elem2_idx, ref _elem2; _list44) { + const auto _base2 = _listSrcPtr44 + _elem2_idx * (8+2*size_t.sizeof); + wit.pumpkin.plugin.common.imports.NbtTag _variant31 = void; + auto _tag31 = cast(uint)(*(cast(ubyte*)(_base2 + 0))); + alias _Tag31 = wit.pumpkin.plugin.common.imports.NbtTag.Tag; + final switch (cast(wit.pumpkin.plugin.common.imports.NbtTag.Tag)_tag31) { + case _Tag31.byte_: { + auto _payload32 = cast(byte)(cast(uint)(*(cast(byte*)(_base2 + 8)))); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.byte_(_payload32); + break; + } + case _Tag31.short_: { + auto _payload33 = cast(short)(cast(uint)(*(cast(short*)(_base2 + 8)))); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.short_(_payload33); + break; + } + case _Tag31.int_: { + auto _payload34 = cast(int)(*(cast(uint*)(_base2 + 8))); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.int_(_payload34); + break; + } + case _Tag31.long_: { + auto _payload35 = cast(long)(*(cast(ulong*)(_base2 + 8))); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.long_(_payload35); + break; + } + case _Tag31.float_: { + auto _payload36 = *(cast(float*)(_base2 + 8)); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.float_(_payload36); + break; + } + case _Tag31.double_: { + auto _payload37 = *(cast(double*)(_base2 + 8)); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.double_(_payload37); + break; + } + case _Tag31.byteArray: { + auto _len10 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr10 = _len10 ? cast(byte*)(*(cast(void**)(_base2 + 8))) : null; + auto _list11 = WitList!(byte)(_ptr10[0.._len10]); + auto _payload38 = _list11; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.byteArray(_payload38); + break; + } + case _Tag31.stringTag: { + auto _len13 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr13 = _len13 ? cast(char*)(*(cast(void**)(_base2 + 8))) : null; + auto _list14 = WitString(_ptr13[0.._len13]); + auto _payload39 = _list14; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.stringTag(_payload39); + break; + } + case _Tag31.listTag: { + auto _len16 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr16 = _len16 ? cast(uint*)(*(cast(void**)(_base2 + 8))) : null; + auto _list17 = WitList!(uint)(_ptr16[0.._len16]); + auto _payload40 = _list17; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.listTag(_payload40); + break; + } + case _Tag31.compound: { + auto _listSrcPtr23 = *(cast(void**)(_base2 + 8)); + auto _listLen23 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _list23 = _listLen23 ? wit.common.mallocSlice!(wit.pumpkin.plugin.common.imports.NbtEntry)(_listLen23) : []; + assert(!_listLen23 || _list23.ptr); + foreach (_elem19_idx, ref _elem19; _list23) { + const auto _base19 = _listSrcPtr23 + _elem19_idx * (3*size_t.sizeof); + auto _len20 = *(cast(size_t*)(_base19 + size_t.sizeof)); + auto _ptr20 = _len20 ? cast(char*)(*(cast(void**)(_base19 + 0))) : null; + auto _list21 = WitString(_ptr20[0.._len20]); + wit.pumpkin.plugin.common.imports.NbtEntry _record22 = { + key: _list21, + value: *(cast(uint*)(_base19 + (2*size_t.sizeof))), + }; + _elem19 = _record22; + } + if (_listLen23) wit.common.free(_listSrcPtr23); + auto _witList24 = WitList!(wit.pumpkin.plugin.common.imports.NbtEntry)(_list23); + auto _payload41 = _witList24; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.compound(_payload41); + break; + } + case _Tag31.intArray: { + auto _len26 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr26 = _len26 ? cast(int*)(*(cast(void**)(_base2 + 8))) : null; + auto _list27 = WitList!(int)(_ptr26[0.._len26]); + auto _payload42 = _list27; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.intArray(_payload42); + break; + } + case _Tag31.longArray: { + auto _len29 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr29 = _len29 ? cast(long*)(*(cast(void**)(_base2 + 8))) : null; + auto _list30 = WitList!(long)(_ptr29[0.._len29]); + auto _payload43 = _list30; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.longArray(_payload43); + break; + } + } + _elem2 = _variant31; + } + if (_listLen44) wit.common.free(_listSrcPtr44); + auto _witList45 = WitList!(wit.pumpkin.plugin.common.imports.NbtTag)(_list44); + wit.pumpkin.plugin.common.imports.NbtTree _record46 = { + root: *(cast(uint*)(_retArea.ptr + size_t.sizeof)), + tags: _witList45, + }; + + _option47 = Option!(NbtTree).makeSome(_record46); + } else { + _option47 = Option!(NbtTree).makeNone; + } + auto _flush48 = _option47; + return _flush48; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.get-custom-data") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.get_custom_data") + static private extern(C) void __import_getCustomData(uint, void*, size_t, void*, size_t, void*) nothrow; + + /++ + Removes a namespaced custom data value from this entity. + +/ + void removeCustomData(in WitString namespace, in WitString key) @trusted nothrow { + __import_removeCustomData(this.__handle, cast(void*)(namespace.ptr), namespace.length, cast(void*)(key.ptr), key.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.remove-custom-data") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.remove_custom_data") + static private extern(C) void __import_removeCustomData(uint, void*, size_t, void*, size_t) nothrow; + + /++ + Returns whether this entity has a namespaced custom data value. + +/ + bool hasCustomData(in WitString namespace, in WitString key) @trusted nothrow { + auto _ret = __import_hasCustomData(this.__handle, cast(void*)(namespace.ptr), namespace.length, cast(void*)(key.ptr), key.length); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.has-custom-data") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.has_custom_data") + static private extern(C) uint __import_hasCustomData(uint, void*, size_t, void*, size_t) nothrow; + + /++ + Returns this entity as a living-entity if it has health and attributes, or none otherwise. + +/ + Option!(LivingEntity) asLiving() @trusted nothrow { + align(4) void[8] _retArea = void; + __import_asLiving(this.__handle, _retArea.ptr); + Option!(LivingEntity) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = LivingEntity(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(LivingEntity).makeSome(_handle2); + } else { + _option3 = Option!(LivingEntity).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.as-living") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.as_living") + static private extern(C) void __import_asLiving(uint, void*) nothrow; + + /++ + Returns this entity as a mob if it is an AI-driven mob entity, or none otherwise. + +/ + Option!(Mob) asMob() @trusted nothrow { + align(4) void[8] _retArea = void; + __import_asMob(this.__handle, _retArea.ptr); + Option!(Mob) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = Mob(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(Mob).makeSome(_handle2); + } else { + _option3 = Option!(Mob).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.as-mob") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.as_mob") + static private extern(C) void __import_asMob(uint, void*) nothrow; + + /++ + Returns whether this entity is a living entity. + +/ + bool isLiving() @trusted nothrow { + auto _ret = __import_isLiving(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.is-living") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.is_living") + static private extern(C) uint __import_isLiving(uint) nothrow; + + /++ + Returns whether this entity is an AI-driven mob. + +/ + bool isMob() @trusted nothrow { + auto _ret = __import_isMob(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]entity.is-mob") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:entity.is_mob") + static private extern(C) uint __import_isMob(uint) nothrow; + } +} + +/++ +Represents a living entity with health, combat stats, attributes, and equipment (mobs, players, armor stands). ++/ +struct LivingEntity { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/world@0.1.0", "[resource-drop]living-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:resource_drop:living_entity") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + Converts back to the base entity handle. + +/ + Entity asEntity() @trusted nothrow { + auto _ret = __import_asEntity(this.__handle); + auto _handle0 = Entity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.as-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.as_entity") + static private extern(C) uint __import_asEntity(uint) nothrow; + + /++ + Returns this living entity as a mob if it has AI/navigation, or none otherwise. + +/ + Option!(Mob) asMob() @trusted nothrow { + align(4) void[8] _retArea = void; + __import_asMob(this.__handle, _retArea.ptr); + Option!(Mob) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = Mob(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(Mob).makeSome(_handle2); + } else { + _option3 = Option!(Mob).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.as-mob") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.as_mob") + static private extern(C) void __import_asMob(uint, void*) nothrow; + + /++ + Returns whether this living entity is an AI-driven mob. + +/ + bool isMob() @trusted nothrow { + auto _ret = __import_isMob(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.is-mob") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.is_mob") + static private extern(C) uint __import_isMob(uint) nothrow; + + /++ + Health & Combat + +/ + float getHealth() @trusted nothrow { + auto _ret = __import_getHealth(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.get-health") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.get_health") + static private extern(C) float __import_getHealth(uint) nothrow; + + /++ + + +/ + void setHealth(float health) @trusted nothrow { + __import_setHealth(this.__handle, health); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.set-health") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.set_health") + static private extern(C) void __import_setHealth(uint, float) nothrow; + + /++ + + +/ + float getMaxHealth() @trusted nothrow { + auto _ret = __import_getMaxHealth(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.get-max-health") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.get_max_health") + static private extern(C) float __import_getMaxHealth(uint) nothrow; + + /++ + + +/ + void setMaxHealth(float maxHealth) @trusted nothrow { + __import_setMaxHealth(this.__handle, maxHealth); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.set-max-health") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.set_max_health") + static private extern(C) void __import_setMaxHealth(uint, float) nothrow; + + /++ + + +/ + void damage(float amount, DamageType damageType) @trusted nothrow { + __import_damage(this.__handle, amount, cast(uint)(damageType)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.damage") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.damage") + static private extern(C) void __import_damage(uint, float, uint) nothrow; + + /++ + + +/ + bool isDead() @trusted nothrow { + auto _ret = __import_isDead(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.is-dead") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.is_dead") + static private extern(C) uint __import_isDead(uint) nothrow; + + /++ + + +/ + float getAbsorption() @trusted nothrow { + auto _ret = __import_getAbsorption(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.get-absorption") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.get_absorption") + static private extern(C) float __import_getAbsorption(uint) nothrow; + + /++ + + +/ + void setAbsorption(float amount) @trusted nothrow { + __import_setAbsorption(this.__handle, amount); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.set-absorption") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.set_absorption") + static private extern(C) void __import_setAbsorption(uint, float) nothrow; + + /++ + Attributes + +/ + double getAttributeValue(Attribute attr) @trusted nothrow { + auto _ret = __import_getAttributeValue(this.__handle, cast(uint)(attr)); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.get-attribute-value") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.get_attribute_value") + static private extern(C) double __import_getAttributeValue(uint, uint) nothrow; + + /++ + + +/ + double getAttributeBase(Attribute attr) @trusted nothrow { + auto _ret = __import_getAttributeBase(this.__handle, cast(uint)(attr)); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.get-attribute-base") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.get_attribute_base") + static private extern(C) double __import_getAttributeBase(uint, uint) nothrow; + + /++ + + +/ + void setAttributeBase(Attribute attr, double value) @trusted nothrow { + __import_setAttributeBase(this.__handle, cast(uint)(attr), value); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.set-attribute-base") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.set_attribute_base") + static private extern(C) void __import_setAttributeBase(uint, uint, double) nothrow; + + /++ + + +/ + void addAttributeModifier(Attribute attr, in AttributeModifier modifier) @trusted nothrow { + __import_addAttributeModifier(this.__handle, cast(uint)(attr), cast(void*)(modifier.id.ptr), modifier.id.length, modifier.amount, cast(uint)(modifier.operation)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.add-attribute-modifier") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.add_attribute_modifier") + static private extern(C) void __import_addAttributeModifier(uint, uint, void*, size_t, double, uint) nothrow; + + /++ + + +/ + void removeAttributeModifier(Attribute attr, in WitString id) @trusted nothrow { + __import_removeAttributeModifier(this.__handle, cast(uint)(attr), cast(void*)(id.ptr), id.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.remove-attribute-modifier") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.remove_attribute_modifier") + static private extern(C) void __import_removeAttributeModifier(uint, uint, void*, size_t) nothrow; + + /++ + + +/ + WitList!(AttributeModifier) getAttributeModifiers(Attribute attr) @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getAttributeModifiers(this.__handle, cast(uint)(attr), _retArea.ptr); + auto _listSrcPtr4 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen4 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list4 = _listLen4 ? wit.common.mallocSlice!(AttributeModifier)(_listLen4) : []; + assert(!_listLen4 || _list4.ptr); + foreach (_elem0_idx, ref _elem0; _list4) { + const auto _base0 = _listSrcPtr4 + _elem0_idx * (16+2*size_t.sizeof); + auto _len1 = *(cast(size_t*)(_base0 + size_t.sizeof)); + auto _ptr1 = _len1 ? cast(char*)(*(cast(void**)(_base0 + 0))) : null; + auto _list2 = WitString(_ptr1[0.._len1]); + wit.pumpkin.plugin.attributes.imports.AttributeModifier _record3 = { + id: _list2, + amount: *(cast(double*)(_base0 + (2*size_t.sizeof))), + operation: cast(wit.pumpkin.plugin.attributes.imports.ModifierOperation)(cast(uint)(*(cast(ubyte*)(_base0 + (8+2*size_t.sizeof))))), + }; + _elem0 = _record3; + } + if (_listLen4) wit.common.free(_listSrcPtr4); + auto _witList5 = WitList!(AttributeModifier)(_list4); + auto _flush6 = _witList5; + return _flush6; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.get-attribute-modifiers") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.get_attribute_modifiers") + static private extern(C) void __import_getAttributeModifiers(uint, uint, void*) nothrow; + + /++ + + +/ + void resetAttribute(Attribute attr) @trusted nothrow { + __import_resetAttribute(this.__handle, cast(uint)(attr)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.reset-attribute") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.reset_attribute") + static private extern(C) void __import_resetAttribute(uint, uint) nothrow; + + /++ + + +/ + void resetAllAttributes() @trusted nothrow { + __import_resetAllAttributes(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.reset-all-attributes") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.reset_all_attributes") + static private extern(C) void __import_resetAllAttributes(uint) nothrow; + + /++ + Equipment + +/ + Option!(ItemStack) getEquipment(EquipmentSlot slot) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getEquipment(this.__handle, cast(uint)(slot), _retArea.ptr); + Option!(ItemStack) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = ItemStack(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(ItemStack).makeSome(_handle2); + } else { + _option3 = Option!(ItemStack).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.get-equipment") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.get_equipment") + static private extern(C) void __import_getEquipment(uint, uint, void*) nothrow; + + /++ + + +/ + void setEquipment(EquipmentSlot slot, in Option!(ItemStack) stack) @trusted nothrow { + uint _option4 = void; + uint _option5 = void; + if (stack.isSome) { + ref _payload3 = stack.unwrap(); + _option4 = 1; + _option5 = _payload3.__handle; + } else { + _option4 = 0; + _option5 = 0; + } + __import_setEquipment(this.__handle, cast(uint)(slot), _option4, _option5); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.set-equipment") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.set_equipment") + static private extern(C) void __import_setEquipment(uint, uint, uint, uint) nothrow; + + /++ + + +/ + void clearEquipment() @trusted nothrow { + __import_clearEquipment(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.clear-equipment") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.clear_equipment") + static private extern(C) void __import_clearEquipment(uint) nothrow; + + /++ + + +/ + int getAge() @trusted nothrow { + auto _ret = __import_getAge(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.get-age") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.get_age") + static private extern(C) uint __import_getAge(uint) nothrow; + + /++ + + +/ + void setAge(int age) @trusted nothrow { + __import_setAge(this.__handle, cast(uint)(age)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.set-age") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.set_age") + static private extern(C) void __import_setAge(uint, uint) nothrow; + + /++ + + +/ + void sendSystemMessage(TextComponent message) @trusted nothrow { + __import_sendSystemMessage(this.__handle, message.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]living-entity.send-system-message") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:living_entity.send_system_message") + static private extern(C) void __import_sendSystemMessage(uint, uint) nothrow; + } +} + +/++ +Represents an AI-driven mob entity with goals, targeting, and pathfinding navigation (e.g. zombies, villagers). ++/ +struct Mob { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/world@0.1.0", "[resource-drop]mob") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:resource_drop:mob") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + Converts back to the base entity handle. + +/ + Entity asEntity() @trusted nothrow { + auto _ret = __import_asEntity(this.__handle); + auto _handle0 = Entity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]mob.as-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:mob.as_entity") + static private extern(C) uint __import_asEntity(uint) nothrow; + + /++ + Converts to the living-entity handle. + +/ + LivingEntity asLiving() @trusted nothrow { + auto _ret = __import_asLiving(this.__handle); + auto _handle0 = LivingEntity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]mob.as-living") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:mob.as_living") + static private extern(C) uint __import_asLiving(uint) nothrow; + + /++ + Goals & Targeting + +/ + void addAiGoal(ubyte priority, in BuiltinAiGoal goal) @trusted nothrow { + uint _variantPart22 = void; + float _variantPart23 = void; + alias _Tag24 = BuiltinAiGoal.Tag; + final switch (goal.tag) { + case _Tag24.swim: { + _variantPart22 = 0; + _variantPart23 = 0; + break; + } + case _Tag24.wanderAround: { + const ref float _payload3 = goal.getWanderAround(); + _variantPart22 = 1; + _variantPart23 = _payload3; + break; + } + case _Tag24.meleeAttack: { + const ref float _payload5 = goal.getMeleeAttack(); + _variantPart22 = 2; + _variantPart23 = _payload5; + break; + } + case _Tag24.lookAtPlayer: { + const ref float _payload7 = goal.getLookAtPlayer(); + _variantPart22 = 3; + _variantPart23 = _payload7; + break; + } + case _Tag24.lookAround: { + _variantPart22 = 4; + _variantPart23 = 0; + break; + } + case _Tag24.escapeDanger: { + const ref float _payload11 = goal.getEscapeDanger(); + _variantPart22 = 5; + _variantPart23 = _payload11; + break; + } + case _Tag24.avoidEntity: { + const ref float _payload13 = goal.getAvoidEntity(); + _variantPart22 = 6; + _variantPart23 = _payload13; + break; + } + case _Tag24.blazeAttack: { + _variantPart22 = 7; + _variantPart23 = 0; + break; + } + case _Tag24.creeperIgnite: { + _variantPart22 = 8; + _variantPart23 = 0; + break; + } + case _Tag24.eatGrass: { + _variantPart22 = 9; + _variantPart23 = 0; + break; + } + case _Tag24.zombieAttack: { + const ref float _payload21 = goal.getZombieAttack(); + _variantPart22 = 10; + _variantPart23 = _payload21; + break; + } + } + __import_addAiGoal(this.__handle, cast(uint)(priority), _variantPart22, _variantPart23); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]mob.add-ai-goal") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:mob.add_ai_goal") + static private extern(C) void __import_addAiGoal(uint, uint, uint, float) nothrow; + + /++ + + +/ + void addCustomAiGoal(ubyte priority, uint goalId) @trusted nothrow { + __import_addCustomAiGoal(this.__handle, cast(uint)(priority), goalId); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]mob.add-custom-ai-goal") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:mob.add_custom_ai_goal") + static private extern(C) void __import_addCustomAiGoal(uint, uint, uint) nothrow; + + /++ + + +/ + void clearAiGoals() @trusted nothrow { + __import_clearAiGoals(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]mob.clear-ai-goals") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:mob.clear_ai_goals") + static private extern(C) void __import_clearAiGoals(uint) nothrow; + + /++ + + +/ + void setAiDisabled(bool disabled) @trusted nothrow { + __import_setAiDisabled(this.__handle, cast(uint)(disabled)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]mob.set-ai-disabled") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:mob.set_ai_disabled") + static private extern(C) void __import_setAiDisabled(uint, uint) nothrow; + + /++ + + +/ + bool isAiDisabled() @trusted nothrow { + auto _ret = __import_isAiDisabled(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]mob.is-ai-disabled") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:mob.is_ai_disabled") + static private extern(C) uint __import_isAiDisabled(uint) nothrow; + + /++ + + +/ + void setTarget(in Option!(Entity) target) @trusted nothrow { + uint _option4 = void; + uint _option5 = void; + if (target.isSome) { + ref _payload3 = target.unwrap(); + _option4 = 1; + _option5 = _payload3.__handle; + } else { + _option4 = 0; + _option5 = 0; + } + __import_setTarget(this.__handle, _option4, _option5); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]mob.set-target") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:mob.set_target") + static private extern(C) void __import_setTarget(uint, uint, uint) nothrow; + + /++ + + +/ + Option!(Entity) getTarget() @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getTarget(this.__handle, _retArea.ptr); + Option!(Entity) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = Entity(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(Entity).makeSome(_handle2); + } else { + _option3 = Option!(Entity).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]mob.get-target") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:mob.get_target") + static private extern(C) void __import_getTarget(uint, void*) nothrow; + + /++ + Pathfinding & Navigation + +/ + bool navigateToPos(in Position pos, double speed) @trusted nothrow { + auto _ret = __import_navigateToPos(this.__handle, pos[0], pos[1], pos[2], speed); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]mob.navigate-to-pos") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:mob.navigate_to_pos") + static private extern(C) uint __import_navigateToPos(uint, double, double, double, double) nothrow; + + /++ + + +/ + bool navigateToEntity(Entity target, double speed) @trusted nothrow { + auto _ret = __import_navigateToEntity(this.__handle, target.__handle, speed); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]mob.navigate-to-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:mob.navigate_to_entity") + static private extern(C) uint __import_navigateToEntity(uint, uint, double) nothrow; + + /++ + + +/ + void stopNavigation() @trusted nothrow { + __import_stopNavigation(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]mob.stop-navigation") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:mob.stop_navigation") + static private extern(C) void __import_stopNavigation(uint) nothrow; + + /++ + + +/ + bool isNavigating() @trusted nothrow { + auto _ret = __import_isNavigating(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]mob.is-navigating") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:mob.is_navigating") + static private extern(C) uint __import_isNavigating(uint) nothrow; + + /++ + + +/ + bool hasReachedDestination() @trusted nothrow { + auto _ret = __import_hasReachedDestination(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]mob.has-reached-destination") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:mob.has_reached_destination") + static private extern(C) uint __import_hasReachedDestination(uint) nothrow; + + /++ + + +/ + void setNavigationSpeed(double speed) @trusted nothrow { + __import_setNavigationSpeed(this.__handle, speed); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]mob.set-navigation-speed") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:mob.set_navigation_speed") + static private extern(C) void __import_setNavigationSpeed(uint, double) nothrow; + + /++ + + +/ + bool canReach(in Position pos, float maxDistance) @trusted nothrow { + auto _ret = __import_canReach(this.__handle, pos[0], pos[1], pos[2], maxDistance); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]mob.can-reach") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:mob.can_reach") + static private extern(C) uint __import_canReach(uint, double, double, double, float) nothrow; + + /++ + + +/ + void setPathfindingMalus(PathNodeType nodeType, float malus) @trusted nothrow { + __import_setPathfindingMalus(this.__handle, cast(uint)(nodeType), malus); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]mob.set-pathfinding-malus") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:mob.set_pathfinding_malus") + static private extern(C) void __import_setPathfindingMalus(uint, uint, float) nothrow; + + /++ + + +/ + float getPathfindingMalus(PathNodeType nodeType) @trusted nothrow { + auto _ret = __import_getPathfindingMalus(this.__handle, cast(uint)(nodeType)); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]mob.get-pathfinding-malus") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:mob.get_pathfinding_malus") + static private extern(C) float __import_getPathfindingMalus(uint, uint) nothrow; + + /++ + + +/ + void lookAt(in Position pos) @trusted nothrow { + __import_lookAt(this.__handle, pos[0], pos[1], pos[2]); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]mob.look-at") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:mob.look_at") + static private extern(C) void __import_lookAt(uint, double, double, double) nothrow; + + /++ + + +/ + void lookAtEntity(Entity target) @trusted nothrow { + __import_lookAtEntity(this.__handle, target.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]mob.look-at-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:mob.look_at_entity") + static private extern(C) void __import_lookAtEntity(uint, uint) nothrow; + + /++ + Returns the specialized mob-specific data for this mob. + +/ + MobData getMobData() @trusted nothrow { + align(8) void[48] _retArea = void; + __import_getMobData(this.__handle, _retArea.ptr); + MobData _variant39 = void; + auto _tag39 = cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0))); + alias _Tag39 = MobData.Tag; + final switch (cast(MobData.Tag)_tag39) { + case _Tag39.sheep: { + SheepData _record1 = { + color: cast(DyeColor)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 8)))), + isSheared: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 9)))) != 0, + }; + auto _payload40 = _record1; + _variant39 = MobData.sheep(_payload40); + break; + } + case _Tag39.wolf: { + Option!(Uuid) _option6 = void; + bool _isSome6 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 16)))) != 0; + if (_isSome6) { + wit.pumpkin.plugin.uuid.imports.Uuid _record5 = { + high: *(cast(ulong*)(_retArea.ptr + 24)), + low: *(cast(ulong*)(_retArea.ptr + 32)), + }; + + _option6 = Option!(Uuid).makeSome(_record5); + } else { + _option6 = Option!(Uuid).makeNone; + } + WolfData _record7 = { + isTamed: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 8)))) != 0, + owner: _option6, + isSitting: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 40)))) != 0, + collarColor: cast(DyeColor)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 41)))), + isAngry: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 42)))) != 0, + isBegging: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 43)))) != 0, + }; + auto _payload41 = _record7; + _variant39 = MobData.wolf(_payload41); + break; + } + case _Tag39.cat: { + Option!(Uuid) _option12 = void; + bool _isSome12 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 16)))) != 0; + if (_isSome12) { + wit.pumpkin.plugin.uuid.imports.Uuid _record11 = { + high: *(cast(ulong*)(_retArea.ptr + 24)), + low: *(cast(ulong*)(_retArea.ptr + 32)), + }; + + _option12 = Option!(Uuid).makeSome(_record11); + } else { + _option12 = Option!(Uuid).makeNone; + } + CatData _record13 = { + isTamed: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 8)))) != 0, + owner: _option12, + isSitting: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 40)))) != 0, + collarColor: cast(DyeColor)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 41)))), + }; + auto _payload42 = _record13; + _variant39 = MobData.cat(_payload42); + break; + } + case _Tag39.villager: { + VillagerData _record15 = { + profession: cast(VillagerProfession)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 8)))), + level: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 9)))), + experience: *(cast(uint*)(_retArea.ptr + 12)), + }; + auto _payload43 = _record15; + _variant39 = MobData.villager(_payload43); + break; + } + case _Tag39.creeper: { + CreeperData _record17 = { + isPowered: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 8)))) != 0, + fuse: cast(int)(*(cast(uint*)(_retArea.ptr + 12))), + isIgnited: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 16)))) != 0, + explosionRadius: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 17)))), + }; + auto _payload44 = _record17; + _variant39 = MobData.creeper(_payload44); + break; + } + case _Tag39.slime: { + SlimeData _record19 = { + size: cast(int)(*(cast(uint*)(_retArea.ptr + 8))), + }; + auto _payload45 = _record19; + _variant39 = MobData.slime(_payload45); + break; + } + case _Tag39.enderman: { + Option!(ushort) _option23 = void; + bool _isSome23 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 8)))) != 0; + if (_isSome23) { + + _option23 = Option!(ushort).makeSome(cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + 10))))); + } else { + _option23 = Option!(ushort).makeNone; + } + EndermanData _record24 = { + carriedBlockState: _option23, + isScreaming: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 12)))) != 0, + isStaring: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 13)))) != 0, + }; + auto _payload46 = _record24; + _variant39 = MobData.enderman(_payload46); + break; + } + case _Tag39.ironGolem: { + IronGolemData _record26 = { + isPlayerCreated: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 8)))) != 0, + }; + auto _payload47 = _record26; + _variant39 = MobData.ironGolem(_payload47); + break; + } + case _Tag39.fox: { + FoxData _record28 = { + isSitting: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 8)))) != 0, + isSleeping: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 9)))) != 0, + isCrouching: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 10)))) != 0, + }; + auto _payload48 = _record28; + _variant39 = MobData.fox(_payload48); + break; + } + case _Tag39.ageable: { + AgeableData _record30 = { + isBaby: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 8)))) != 0, + age: cast(int)(*(cast(uint*)(_retArea.ptr + 12))), + inLoveTicks: cast(int)(*(cast(uint*)(_retArea.ptr + 16))), + }; + auto _payload49 = _record30; + _variant39 = MobData.ageable(_payload49); + break; + } + case _Tag39.zombie: { + ZombieData _record32 = { + isBaby: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 8)))) != 0, + canBreakDoors: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 9)))) != 0, + }; + auto _payload50 = _record32; + _variant39 = MobData.zombie(_payload50); + break; + } + case _Tag39.shulker: { + Option!(DyeColor) _option36 = void; + bool _isSome36 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 10)))) != 0; + if (_isSome36) { + + _option36 = Option!(DyeColor).makeSome(cast(DyeColor)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 11))))); + } else { + _option36 = Option!(DyeColor).makeNone; + } + ShulkerData _record37 = { + attachedFace: cast(BlockDirection)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 8)))), + peekAmount: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 9)))), + color: _option36, + }; + auto _payload51 = _record37; + _variant39 = MobData.shulker(_payload51); + break; + } + case _Tag39.generic: { + _variant39 = MobData.generic(); + break; + } + } + auto _flush53 = _variant39; + return _flush53; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]mob.get-mob-data") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:mob.get_mob_data") + static private extern(C) void __import_getMobData(uint, void*) nothrow; + + /++ + Sets the specialized mob-specific data for this mob. + Returns false if the provided data variant is incompatible with this mob. + +/ + bool setMobData(in MobData data) @trusted nothrow { + uint _variantPart52 = void; + uint _variantPart53 = void; + uint _variantPart54 = void; + ulong _variantPart55 = void; + ulong _variantPart56 = void; + uint _variantPart57 = void; + uint _variantPart58 = void; + uint _variantPart59 = void; + uint _variantPart60 = void; + alias _Tag61 = MobData.Tag; + final switch (data.tag) { + case _Tag61.sheep: { + const ref SheepData _payload1 = data.getSheep(); + _variantPart52 = 0; + _variantPart53 = cast(uint)(_payload1.color); + _variantPart54 = cast(uint)(_payload1.isSheared); + _variantPart55 = 0; + _variantPart56 = 0; + _variantPart57 = 0; + _variantPart58 = 0; + _variantPart59 = 0; + _variantPart60 = 0; + break; + } + case _Tag61.wolf: { + const ref WolfData _payload3 = data.getWolf(); + uint _option8 = void; + ulong _option9 = void; + ulong _option10 = void; + if (_payload3.owner.isSome) { + ref _payload7 = _payload3.owner.unwrap(); + _option8 = 1; + _option9 = _payload7.high; + _option10 = _payload7.low; + } else { + _option8 = 0; + _option9 = 0; + _option10 = 0; + } + _variantPart52 = 1; + _variantPart53 = cast(uint)(_payload3.isTamed); + _variantPart54 = _option8; + _variantPart55 = _option9; + _variantPart56 = _option10; + _variantPart57 = cast(uint)(_payload3.isSitting); + _variantPart58 = cast(uint)(_payload3.collarColor); + _variantPart59 = cast(uint)(_payload3.isAngry); + _variantPart60 = cast(uint)(_payload3.isBegging); + break; + } + case _Tag61.cat: { + const ref CatData _payload12 = data.getCat(); + uint _option17 = void; + ulong _option18 = void; + ulong _option19 = void; + if (_payload12.owner.isSome) { + ref _payload16 = _payload12.owner.unwrap(); + _option17 = 1; + _option18 = _payload16.high; + _option19 = _payload16.low; + } else { + _option17 = 0; + _option18 = 0; + _option19 = 0; + } + _variantPart52 = 2; + _variantPart53 = cast(uint)(_payload12.isTamed); + _variantPart54 = _option17; + _variantPart55 = _option18; + _variantPart56 = _option19; + _variantPart57 = cast(uint)(_payload12.isSitting); + _variantPart58 = cast(uint)(_payload12.collarColor); + _variantPart59 = 0; + _variantPart60 = 0; + break; + } + case _Tag61.villager: { + const ref VillagerData _payload21 = data.getVillager(); + _variantPart52 = 3; + _variantPart53 = cast(uint)(_payload21.profession); + _variantPart54 = cast(uint)(_payload21.level); + _variantPart55 = cast(ulong)(_payload21.experience); + _variantPart56 = 0; + _variantPart57 = 0; + _variantPart58 = 0; + _variantPart59 = 0; + _variantPart60 = 0; + break; + } + case _Tag61.creeper: { + const ref CreeperData _payload23 = data.getCreeper(); + _variantPart52 = 4; + _variantPart53 = cast(uint)(_payload23.isPowered); + _variantPart54 = cast(uint)(_payload23.fuse); + _variantPart55 = cast(ulong)(cast(uint)(_payload23.isIgnited)); + _variantPart56 = cast(ulong)(cast(uint)(_payload23.explosionRadius)); + _variantPart57 = 0; + _variantPart58 = 0; + _variantPart59 = 0; + _variantPart60 = 0; + break; + } + case _Tag61.slime: { + const ref SlimeData _payload25 = data.getSlime(); + _variantPart52 = 5; + _variantPart53 = cast(uint)(_payload25.size); + _variantPart54 = 0; + _variantPart55 = 0; + _variantPart56 = 0; + _variantPart57 = 0; + _variantPart58 = 0; + _variantPart59 = 0; + _variantPart60 = 0; + break; + } + case _Tag61.enderman: { + const ref EndermanData _payload27 = data.getEnderman(); + uint _option32 = void; + uint _option33 = void; + if (_payload27.carriedBlockState.isSome) { + ref _payload31 = _payload27.carriedBlockState.unwrap(); + _option32 = 1; + _option33 = cast(uint)(_payload31); + } else { + _option32 = 0; + _option33 = 0; + } + _variantPart52 = 6; + _variantPart53 = _option32; + _variantPart54 = _option33; + _variantPart55 = cast(ulong)(cast(uint)(_payload27.isScreaming)); + _variantPart56 = cast(ulong)(cast(uint)(_payload27.isStaring)); + _variantPart57 = 0; + _variantPart58 = 0; + _variantPart59 = 0; + _variantPart60 = 0; + break; + } + case _Tag61.ironGolem: { + const ref IronGolemData _payload35 = data.getIronGolem(); + _variantPart52 = 7; + _variantPart53 = cast(uint)(_payload35.isPlayerCreated); + _variantPart54 = 0; + _variantPart55 = 0; + _variantPart56 = 0; + _variantPart57 = 0; + _variantPart58 = 0; + _variantPart59 = 0; + _variantPart60 = 0; + break; + } + case _Tag61.fox: { + const ref FoxData _payload37 = data.getFox(); + _variantPart52 = 8; + _variantPart53 = cast(uint)(_payload37.isSitting); + _variantPart54 = cast(uint)(_payload37.isSleeping); + _variantPart55 = cast(ulong)(cast(uint)(_payload37.isCrouching)); + _variantPart56 = 0; + _variantPart57 = 0; + _variantPart58 = 0; + _variantPart59 = 0; + _variantPart60 = 0; + break; + } + case _Tag61.ageable: { + const ref AgeableData _payload39 = data.getAgeable(); + _variantPart52 = 9; + _variantPart53 = cast(uint)(_payload39.isBaby); + _variantPart54 = cast(uint)(_payload39.age); + _variantPart55 = cast(ulong)(cast(uint)(_payload39.inLoveTicks)); + _variantPart56 = 0; + _variantPart57 = 0; + _variantPart58 = 0; + _variantPart59 = 0; + _variantPart60 = 0; + break; + } + case _Tag61.zombie: { + const ref ZombieData _payload41 = data.getZombie(); + _variantPart52 = 10; + _variantPart53 = cast(uint)(_payload41.isBaby); + _variantPart54 = cast(uint)(_payload41.canBreakDoors); + _variantPart55 = 0; + _variantPart56 = 0; + _variantPart57 = 0; + _variantPart58 = 0; + _variantPart59 = 0; + _variantPart60 = 0; + break; + } + case _Tag61.shulker: { + const ref ShulkerData _payload43 = data.getShulker(); + uint _option48 = void; + uint _option49 = void; + if (_payload43.color.isSome) { + ref _payload47 = _payload43.color.unwrap(); + _option48 = 1; + _option49 = cast(uint)(_payload47); + } else { + _option48 = 0; + _option49 = 0; + } + _variantPart52 = 11; + _variantPart53 = cast(uint)(_payload43.attachedFace); + _variantPart54 = cast(uint)(_payload43.peekAmount); + _variantPart55 = cast(ulong)(_option48); + _variantPart56 = cast(ulong)(_option49); + _variantPart57 = 0; + _variantPart58 = 0; + _variantPart59 = 0; + _variantPart60 = 0; + break; + } + case _Tag61.generic: { + _variantPart52 = 12; + _variantPart53 = 0; + _variantPart54 = 0; + _variantPart55 = 0; + _variantPart56 = 0; + _variantPart57 = 0; + _variantPart58 = 0; + _variantPart59 = 0; + _variantPart60 = 0; + break; + } + } + auto _ret = __import_setMobData(this.__handle, _variantPart52, _variantPart53, _variantPart54, _variantPart55, _variantPart56, _variantPart57, _variantPart58, _variantPart59, _variantPart60); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]mob.set-mob-data") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:mob.set_mob_data") + static private extern(C) uint __import_setMobData(uint, uint, uint, uint, ulong, ulong, uint, uint, uint, uint) nothrow; + + /++ + Sets the number of freeze ticks on this entity (0 to 140). + +/ + void setFreezeTicks(int ticks) @trusted nothrow { + __import_setFreezeTicks(this.__handle, cast(uint)(ticks)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]mob.set-freeze-ticks") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:mob.set_freeze_ticks") + static private extern(C) void __import_setFreezeTicks(uint, uint) nothrow; + + /++ + Returns the number of freeze ticks currently on this entity. + +/ + int getFreezeTicks() @trusted nothrow { + auto _ret = __import_getFreezeTicks(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]mob.get-freeze-ticks") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:mob.get_freeze_ticks") + static private extern(C) uint __import_getFreezeTicks(uint) nothrow; + } +} + +/++ +Result of an entity ray-trace operation. ++/ +struct RayTraceEntityResult { + /++ + The entity that was hit. + +/ + Entity entity; + + /++ + The exact hit coordinates in world space. + +/ + Position hitPos; + + /++ + The distance from the ray start to the hit position. + +/ + double distance; + + void witFree() @nogc nothrow { + } + + void witDrop() @nogc nothrow { + entity.witDrop; + } + + RayTraceEntityResult witClone() const @nogc nothrow { + RayTraceEntityResult clone = void; + clone.entity = this.entity.witClone; + clone.hitPos = this.hitPos.witClone; + clone.distance = this.distance.witClone; + return clone; + } +} + +/++ + ++/ +struct Chunk { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/world@0.1.0", "[resource-drop]chunk") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:resource_drop:chunk") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + Gets the chunk's X coordinate. + +/ + int getX() @trusted nothrow { + auto _ret = __import_getX(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk.get-x") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk.get_x") + static private extern(C) uint __import_getX(uint) nothrow; + + /++ + Gets the chunk's Z coordinate. + +/ + int getZ() @trusted nothrow { + auto _ret = __import_getZ(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk.get-z") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk.get_z") + static private extern(C) uint __import_getZ(uint) nothrow; + + /++ + Gets the block state ID at the specified position relative to the chunk. + X and Z must be in the range [0, 15]. + +/ + ushort getBlockStateId(in BlockPos pos) @trusted nothrow { + auto _ret = __import_getBlockStateId(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z)); + return cast(ushort)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk.get-block-state-id") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk.get_block_state_id") + static private extern(C) uint __import_getBlockStateId(uint, uint, uint, uint) nothrow; + + /++ + Gets detailed block state information at the specified position relative to the chunk. + X and Z must be in the range [0, 15]. + +/ + BlockState getBlockState(in BlockPos pos) @trusted nothrow { + align(size_t.sizeof) void[(32+10*size_t.sizeof)] _retArea = void; + __import_getBlockState(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z), _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _len2 = *(cast(size_t*)(_retArea.ptr + (24+4*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(BoundingBox*)(*(cast(void**)(_retArea.ptr + (24+3*size_t.sizeof)))) : null; + auto _list3 = WitList!(BoundingBox)(_ptr2[0.._len2]); + auto _len4 = *(cast(size_t*)(_retArea.ptr + (24+6*size_t.sizeof))); + auto _ptr4 = _len4 ? cast(BoundingBox*)(*(cast(void**)(_retArea.ptr + (24+5*size_t.sizeof)))) : null; + auto _list5 = WitList!(BoundingBox)(_ptr4[0.._len4]); + auto _listSrcPtr12 = *(cast(void**)(_retArea.ptr + (32+8*size_t.sizeof))); + auto _listLen12 = *(cast(size_t*)(_retArea.ptr + (32+9*size_t.sizeof))); + auto _list12 = _listLen12 ? wit.common.mallocSlice!(Tuple!(WitString, WitString))(_listLen12) : []; + assert(!_listLen12 || _list12.ptr); + foreach (_elem6_idx, ref _elem6; _list12) { + const auto _base6 = _listSrcPtr12 + _elem6_idx * (4*size_t.sizeof); + auto _len7 = *(cast(size_t*)(_base6 + size_t.sizeof)); + auto _ptr7 = _len7 ? cast(char*)(*(cast(void**)(_base6 + 0))) : null; + auto _list8 = WitString(_ptr7[0.._len7]); + auto _len9 = *(cast(size_t*)(_base6 + (3*size_t.sizeof))); + auto _ptr9 = _len9 ? cast(char*)(*(cast(void**)(_base6 + (2*size_t.sizeof)))) : null; + auto _list10 = WitString(_ptr9[0.._len9]); + auto _tuple11 = Tuple!(WitString, WitString)( + _list8, + _list10, + ); + _elem6 = _tuple11; + } + if (_listLen12) wit.common.free(_listSrcPtr12); + auto _witList13 = WitList!(Tuple!(WitString, WitString))(_list12); + BlockState _record14 = { + id: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + 0)))), + blockId: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + 2)))), + blockName: _list1, + luminance: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (3*size_t.sizeof))))), + opacity: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (1+3*size_t.sizeof))))), + hardness: *(cast(float*)(_retArea.ptr + (4+3*size_t.sizeof))), + isAir: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof))))) != 0, + isLiquid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (9+3*size_t.sizeof))))) != 0, + isSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (10+3*size_t.sizeof))))) != 0, + isFullCube: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (11+3*size_t.sizeof))))) != 0, + pistonBehavior: cast(PistonBehavior)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (12+3*size_t.sizeof))))), + hasRandomTicks: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (13+3*size_t.sizeof))))) != 0, + burnable: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (14+3*size_t.sizeof))))) != 0, + toolRequired: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (15+3*size_t.sizeof))))) != 0, + sidedTransparency: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (16+3*size_t.sizeof))))) != 0, + replaceable: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (17+3*size_t.sizeof))))) != 0, + isSolidBlock: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (18+3*size_t.sizeof))))) != 0, + blockEntityType: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + (20+3*size_t.sizeof))))), + instrument: cast(NoteblockInstrument)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (22+3*size_t.sizeof))))), + collisionShapes: _list3, + outlineShapes: _list5, + downSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (24+7*size_t.sizeof))))) != 0, + upSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (25+7*size_t.sizeof))))) != 0, + northSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (26+7*size_t.sizeof))))) != 0, + southSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (27+7*size_t.sizeof))))) != 0, + westSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (28+7*size_t.sizeof))))) != 0, + eastSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (29+7*size_t.sizeof))))) != 0, + downCenterSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (30+7*size_t.sizeof))))) != 0, + upCenterSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (31+7*size_t.sizeof))))) != 0, + mapColor: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (32+7*size_t.sizeof))))), + properties: _witList13, + }; + auto _flush15 = _record14; + return _flush15; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk.get-block-state") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk.get_block_state") + static private extern(C) void __import_getBlockState(uint, uint, uint, uint, void*) nothrow; + + /++ + Sets the block state at the specified position relative to the chunk. + X and Z must be in the range [0, 15]. + +/ + void setBlockState(in BlockPos pos, ushort state) @trusted nothrow { + __import_setBlockState(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z), cast(uint)(state)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk.set-block-state") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk.set_block_state") + static private extern(C) void __import_setBlockState(uint, uint, uint, uint, uint) nothrow; + + /++ + Gets the block at the specified position relative to the chunk. + X and Z must be in the range [0, 15]. + +/ + Block getBlock(in BlockPos pos) @trusted nothrow { + align(size_t.sizeof) void[(32+6*size_t.sizeof)] _retArea = void; + __import_getBlock(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z), _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _len2 = *(cast(size_t*)(_retArea.ptr + (24+5*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(ushort*)(*(cast(void**)(_retArea.ptr + (24+4*size_t.sizeof)))) : null; + auto _list3 = WitList!(ushort)(_ptr2[0.._len2]); + Option!(Flammable) _option7 = void; + bool _isSome7 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (27+6*size_t.sizeof))))) != 0; + if (_isSome7) { + Flammable _record6 = { + spreadChance: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (28+6*size_t.sizeof))))), + burnChance: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (29+6*size_t.sizeof))))), + }; + + _option7 = Option!(Flammable).makeSome(_record6); + } else { + _option7 = Option!(Flammable).makeNone; + } + Block _record8 = { + id: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + 0)))), + name: _list1, + hardness: *(cast(float*)(_retArea.ptr + (3*size_t.sizeof))), + blastResistance: *(cast(float*)(_retArea.ptr + (4+3*size_t.sizeof))), + mapColor: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof))))), + slipperiness: *(cast(float*)(_retArea.ptr + (12+3*size_t.sizeof))), + velocityMultiplier: *(cast(float*)(_retArea.ptr + (16+3*size_t.sizeof))), + jumpVelocityMultiplier: *(cast(float*)(_retArea.ptr + (20+3*size_t.sizeof))), + itemId: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + (24+3*size_t.sizeof))))), + defaultStateId: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + (26+3*size_t.sizeof))))), + stateIds: _list3, + isSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (24+6*size_t.sizeof))))) != 0, + isAir: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (25+6*size_t.sizeof))))) != 0, + isFlammable: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (26+6*size_t.sizeof))))) != 0, + flammable: _option7, + }; + auto _flush9 = _record8; + return _flush9; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk.get-block") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk.get_block") + static private extern(C) void __import_getBlock(uint, uint, uint, uint, void*) nothrow; + + /++ + Sets the block at the specified position relative to the chunk using its default state. + X and Z must be in the range [0, 15]. + +/ + void setBlock(in BlockPos pos, in Block block) @trusted nothrow { + align(size_t.sizeof) void[(48+6*size_t.sizeof)] _retArea = void; + *cast(uint*)(_retArea.ptr + 0) = cast(uint)(this.__handle); + *cast(uint*)(_retArea.ptr + 4) = cast(uint)(cast(uint)(pos.x)); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(pos.y)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(pos.z)); + *cast(ushort*)(_retArea.ptr + 16) = cast(ushort)(cast(uint)(block.id)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(block.name.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(block.name.ptr)); + *cast(float*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(float)(block.hardness); + *cast(float*)(_retArea.ptr + (20+3*size_t.sizeof)) = cast(float)(block.blastResistance); + *cast(ubyte*)(_retArea.ptr + (24+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(block.mapColor)); + *cast(float*)(_retArea.ptr + (28+3*size_t.sizeof)) = cast(float)(block.slipperiness); + *cast(float*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(float)(block.velocityMultiplier); + *cast(float*)(_retArea.ptr + (36+3*size_t.sizeof)) = cast(float)(block.jumpVelocityMultiplier); + *cast(ushort*)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(ushort)(cast(uint)(block.itemId)); + *cast(ushort*)(_retArea.ptr + (42+3*size_t.sizeof)) = cast(ushort)(cast(uint)(block.defaultStateId)); + *cast(size_t*)(_retArea.ptr + (40+5*size_t.sizeof)) = cast(size_t)(block.stateIds.length); + *cast(void**)(_retArea.ptr + (40+4*size_t.sizeof)) = cast(void*)(cast(void*)(block.stateIds.ptr)); + *cast(ubyte*)(_retArea.ptr + (40+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(block.isSolid)); + *cast(ubyte*)(_retArea.ptr + (41+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(block.isAir)); + *cast(ubyte*)(_retArea.ptr + (42+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(block.isFlammable)); + if (block.flammable.isSome) { + ref _payload3 = block.flammable.unwrap(); + *cast(ubyte*)(_retArea.ptr + (43+6*size_t.sizeof)) = cast(ubyte)(1); + *cast(ubyte*)(_retArea.ptr + (44+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload3.spreadChance)); + *cast(ubyte*)(_retArea.ptr + (45+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload3.burnChance)); + } else { + *cast(ubyte*)(_retArea.ptr + (43+6*size_t.sizeof)) = cast(ubyte)(0); + } + __import_setBlock(_retArea.ptr); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk.set-block") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk.set_block") + static private extern(C) void __import_setBlock(void*) nothrow; + + /++ + Sets the block by block ID at the specified position relative to the chunk using its default state. + X and Z must be in the range [0, 15]. + +/ + void setBlockById(in BlockPos pos, ushort blockId) @trusted nothrow { + __import_setBlockById(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z), cast(uint)(blockId)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk.set-block-by-id") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk.set_block_by_id") + static private extern(C) void __import_setBlockById(uint, uint, uint, uint, uint) nothrow; + + /++ + Gets the biome at the specified position relative to the chunk. + X and Z must be in the range [0, 15]. + +/ + Biome getBiome(in BlockPos pos) @trusted nothrow { + auto _ret = __import_getBiome(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z)); + return cast(wit.pumpkin.plugin.biomes.imports.Biome)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk.get-biome") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk.get_biome") + static private extern(C) uint __import_getBiome(uint, uint, uint, uint) nothrow; + + /++ + Gets the block entity at the specified position relative to the chunk, if any. + X and Z must be in the range [0, 15]. + +/ + Option!(BlockEntityType) getBlockEntity(in BlockPos pos) @trusted nothrow { + align(4) void[12] _retArea = void; + __import_getBlockEntity(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z), _retArea.ptr); + Option!(BlockEntityType) _option159 = void; + bool _isSome159 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome159) { + wit.pumpkin.plugin.block_entity.imports.BlockEntityType _variant106 = void; + auto _tag106 = cast(uint)(*(cast(ubyte*)(_retArea.ptr + 4))); + alias _Tag106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.Tag; + final switch (cast(wit.pumpkin.plugin.block_entity.imports.BlockEntityType.Tag)_tag106) { + case _Tag106.commandBlockEntity: { + auto _handle3 = wit.pumpkin.plugin.block_entity.imports.CommandBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload107 = _handle3; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.commandBlockEntity(_payload107); + break; + } + case _Tag106.signBlockEntity: { + auto _handle5 = wit.pumpkin.plugin.block_entity.imports.SignBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload108 = _handle5; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.signBlockEntity(_payload108); + break; + } + case _Tag106.hangingSignBlockEntity: { + auto _handle7 = wit.pumpkin.plugin.block_entity.imports.HangingSignBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload109 = _handle7; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.hangingSignBlockEntity(_payload109); + break; + } + case _Tag106.jukeboxBlockEntity: { + auto _handle9 = wit.pumpkin.plugin.block_entity.imports.JukeboxBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload110 = _handle9; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.jukeboxBlockEntity(_payload110); + break; + } + case _Tag106.chestBlockEntity: { + auto _handle11 = wit.pumpkin.plugin.block_entity.imports.ChestBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload111 = _handle11; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.chestBlockEntity(_payload111); + break; + } + case _Tag106.trappedChestBlockEntity: { + auto _handle13 = wit.pumpkin.plugin.block_entity.imports.TrappedChestBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload112 = _handle13; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.trappedChestBlockEntity(_payload112); + break; + } + case _Tag106.mobSpawnerBlockEntity: { + auto _handle15 = wit.pumpkin.plugin.block_entity.imports.MobSpawnerBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload113 = _handle15; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.mobSpawnerBlockEntity(_payload113); + break; + } + case _Tag106.mapBlockEntity: { + auto _handle17 = wit.pumpkin.plugin.block_entity.imports.MapBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload114 = _handle17; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.mapBlockEntity(_payload114); + break; + } + case _Tag106.bannerBlockEntity: { + auto _handle19 = wit.pumpkin.plugin.block_entity.imports.BannerBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload115 = _handle19; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.bannerBlockEntity(_payload115); + break; + } + case _Tag106.barrelBlockEntity: { + auto _handle21 = wit.pumpkin.plugin.block_entity.imports.BarrelBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload116 = _handle21; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.barrelBlockEntity(_payload116); + break; + } + case _Tag106.beaconBlockEntity: { + auto _handle23 = wit.pumpkin.plugin.block_entity.imports.BeaconBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload117 = _handle23; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.beaconBlockEntity(_payload117); + break; + } + case _Tag106.bedBlockEntity: { + auto _handle25 = wit.pumpkin.plugin.block_entity.imports.BedBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload118 = _handle25; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.bedBlockEntity(_payload118); + break; + } + case _Tag106.beehiveBlockEntity: { + auto _handle27 = wit.pumpkin.plugin.block_entity.imports.BeehiveBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload119 = _handle27; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.beehiveBlockEntity(_payload119); + break; + } + case _Tag106.bellBlockEntity: { + auto _handle29 = wit.pumpkin.plugin.block_entity.imports.BellBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload120 = _handle29; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.bellBlockEntity(_payload120); + break; + } + case _Tag106.blastingFurnaceBlockEntity: { + auto _handle31 = wit.pumpkin.plugin.block_entity.imports.BlastingFurnaceBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload121 = _handle31; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.blastingFurnaceBlockEntity(_payload121); + break; + } + case _Tag106.brewingStandBlockEntity: { + auto _handle33 = wit.pumpkin.plugin.block_entity.imports.BrewingStandBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload122 = _handle33; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.brewingStandBlockEntity(_payload122); + break; + } + case _Tag106.brushableBlockBlockEntity: { + auto _handle35 = wit.pumpkin.plugin.block_entity.imports.BrushableBlockBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload123 = _handle35; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.brushableBlockBlockEntity(_payload123); + break; + } + case _Tag106.calibratedSculkSensorBlockEntity: { + auto _handle37 = wit.pumpkin.plugin.block_entity.imports.CalibratedSculkSensorBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload124 = _handle37; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.calibratedSculkSensorBlockEntity(_payload124); + break; + } + case _Tag106.campfireBlockEntity: { + auto _handle39 = wit.pumpkin.plugin.block_entity.imports.CampfireBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload125 = _handle39; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.campfireBlockEntity(_payload125); + break; + } + case _Tag106.chiseledBookshelfBlockEntity: { + auto _handle41 = wit.pumpkin.plugin.block_entity.imports.ChiseledBookshelfBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload126 = _handle41; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.chiseledBookshelfBlockEntity(_payload126); + break; + } + case _Tag106.comparatorBlockEntity: { + auto _handle43 = wit.pumpkin.plugin.block_entity.imports.ComparatorBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload127 = _handle43; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.comparatorBlockEntity(_payload127); + break; + } + case _Tag106.conduitBlockEntity: { + auto _handle45 = wit.pumpkin.plugin.block_entity.imports.ConduitBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload128 = _handle45; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.conduitBlockEntity(_payload128); + break; + } + case _Tag106.copperGolemStatueBlockEntity: { + auto _handle47 = wit.pumpkin.plugin.block_entity.imports.CopperGolemStatueBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload129 = _handle47; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.copperGolemStatueBlockEntity(_payload129); + break; + } + case _Tag106.crafterBlockEntity: { + auto _handle49 = wit.pumpkin.plugin.block_entity.imports.CrafterBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload130 = _handle49; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.crafterBlockEntity(_payload130); + break; + } + case _Tag106.creakingHeartBlockEntity: { + auto _handle51 = wit.pumpkin.plugin.block_entity.imports.CreakingHeartBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload131 = _handle51; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.creakingHeartBlockEntity(_payload131); + break; + } + case _Tag106.daylightDetectorBlockEntity: { + auto _handle53 = wit.pumpkin.plugin.block_entity.imports.DaylightDetectorBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload132 = _handle53; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.daylightDetectorBlockEntity(_payload132); + break; + } + case _Tag106.decoratedPotBlockEntity: { + auto _handle55 = wit.pumpkin.plugin.block_entity.imports.DecoratedPotBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload133 = _handle55; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.decoratedPotBlockEntity(_payload133); + break; + } + case _Tag106.dispenserBlockEntity: { + auto _handle57 = wit.pumpkin.plugin.block_entity.imports.DispenserBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload134 = _handle57; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.dispenserBlockEntity(_payload134); + break; + } + case _Tag106.dropperBlockEntity: { + auto _handle59 = wit.pumpkin.plugin.block_entity.imports.DropperBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload135 = _handle59; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.dropperBlockEntity(_payload135); + break; + } + case _Tag106.enchantingTableBlockEntity: { + auto _handle61 = wit.pumpkin.plugin.block_entity.imports.EnchantingTableBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload136 = _handle61; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.enchantingTableBlockEntity(_payload136); + break; + } + case _Tag106.endGatewayBlockEntity: { + auto _handle63 = wit.pumpkin.plugin.block_entity.imports.EndGatewayBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload137 = _handle63; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.endGatewayBlockEntity(_payload137); + break; + } + case _Tag106.endPortalBlockEntity: { + auto _handle65 = wit.pumpkin.plugin.block_entity.imports.EndPortalBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload138 = _handle65; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.endPortalBlockEntity(_payload138); + break; + } + case _Tag106.enderChestBlockEntity: { + auto _handle67 = wit.pumpkin.plugin.block_entity.imports.EnderChestBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload139 = _handle67; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.enderChestBlockEntity(_payload139); + break; + } + case _Tag106.furnaceBlockEntity: { + auto _handle69 = wit.pumpkin.plugin.block_entity.imports.FurnaceBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload140 = _handle69; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.furnaceBlockEntity(_payload140); + break; + } + case _Tag106.hopperBlockEntity: { + auto _handle71 = wit.pumpkin.plugin.block_entity.imports.HopperBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload141 = _handle71; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.hopperBlockEntity(_payload141); + break; + } + case _Tag106.jigsawBlockEntity: { + auto _handle73 = wit.pumpkin.plugin.block_entity.imports.JigsawBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload142 = _handle73; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.jigsawBlockEntity(_payload142); + break; + } + case _Tag106.lecternBlockEntity: { + auto _handle75 = wit.pumpkin.plugin.block_entity.imports.LecternBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload143 = _handle75; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.lecternBlockEntity(_payload143); + break; + } + case _Tag106.pistonBlockEntity: { + auto _handle77 = wit.pumpkin.plugin.block_entity.imports.PistonBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload144 = _handle77; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.pistonBlockEntity(_payload144); + break; + } + case _Tag106.potentSulfurBlockEntity: { + auto _handle79 = wit.pumpkin.plugin.block_entity.imports.PotentSulfurBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload145 = _handle79; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.potentSulfurBlockEntity(_payload145); + break; + } + case _Tag106.sculkCatalystBlockEntity: { + auto _handle81 = wit.pumpkin.plugin.block_entity.imports.SculkCatalystBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload146 = _handle81; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.sculkCatalystBlockEntity(_payload146); + break; + } + case _Tag106.sculkSensorBlockEntity: { + auto _handle83 = wit.pumpkin.plugin.block_entity.imports.SculkSensorBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload147 = _handle83; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.sculkSensorBlockEntity(_payload147); + break; + } + case _Tag106.sculkShriekerBlockEntity: { + auto _handle85 = wit.pumpkin.plugin.block_entity.imports.SculkShriekerBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload148 = _handle85; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.sculkShriekerBlockEntity(_payload148); + break; + } + case _Tag106.shelfBlockEntity: { + auto _handle87 = wit.pumpkin.plugin.block_entity.imports.ShelfBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload149 = _handle87; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.shelfBlockEntity(_payload149); + break; + } + case _Tag106.shulkerBoxBlockEntity: { + auto _handle89 = wit.pumpkin.plugin.block_entity.imports.ShulkerBoxBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload150 = _handle89; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.shulkerBoxBlockEntity(_payload150); + break; + } + case _Tag106.skullBlockEntity: { + auto _handle91 = wit.pumpkin.plugin.block_entity.imports.SkullBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload151 = _handle91; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.skullBlockEntity(_payload151); + break; + } + case _Tag106.smokerBlockEntity: { + auto _handle93 = wit.pumpkin.plugin.block_entity.imports.SmokerBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload152 = _handle93; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.smokerBlockEntity(_payload152); + break; + } + case _Tag106.structureBlockBlockEntity: { + auto _handle95 = wit.pumpkin.plugin.block_entity.imports.StructureBlockBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload153 = _handle95; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.structureBlockBlockEntity(_payload153); + break; + } + case _Tag106.testBlockBlockEntity: { + auto _handle97 = wit.pumpkin.plugin.block_entity.imports.TestBlockBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload154 = _handle97; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.testBlockBlockEntity(_payload154); + break; + } + case _Tag106.testInstanceBlockBlockEntity: { + auto _handle99 = wit.pumpkin.plugin.block_entity.imports.TestInstanceBlockBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload155 = _handle99; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.testInstanceBlockBlockEntity(_payload155); + break; + } + case _Tag106.trialSpawnerBlockEntity: { + auto _handle101 = wit.pumpkin.plugin.block_entity.imports.TrialSpawnerBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload156 = _handle101; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.trialSpawnerBlockEntity(_payload156); + break; + } + case _Tag106.vaultBlockEntity: { + auto _handle103 = wit.pumpkin.plugin.block_entity.imports.VaultBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload157 = _handle103; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.vaultBlockEntity(_payload157); + break; + } + case _Tag106.containerBlockEntity: { + auto _handle105 = wit.pumpkin.plugin.block_entity.imports.ContainerBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload158 = _handle105; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.containerBlockEntity(_payload158); + break; + } + } + + _option159 = Option!(BlockEntityType).makeSome(_variant106); + } else { + _option159 = Option!(BlockEntityType).makeNone; + } + auto _flush160 = _option159; + return _flush160; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk.get_block_entity") + static private extern(C) void __import_getBlockEntity(uint, uint, uint, uint, void*) nothrow; + + /++ + Gets the highest non-air block Y coordinate at the specified X and Z relative to the chunk. + X and Z must be in the range [0, 15]. + +/ + int getTopBlockY(int x, int z) @trusted nothrow { + auto _ret = __import_getTopBlockY(this.__handle, cast(uint)(x), cast(uint)(z)); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk.get-top-block-y") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk.get_top_block_y") + static private extern(C) uint __import_getTopBlockY(uint, uint, uint) nothrow; + + /++ + Gets the sky light level at the specified position relative to the chunk. + X and Z must be in the range [0, 15]. + +/ + ubyte getSkyLight(in BlockPos pos) @trusted nothrow { + auto _ret = __import_getSkyLight(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z)); + return cast(ubyte)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk.get-sky-light") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk.get_sky_light") + static private extern(C) uint __import_getSkyLight(uint, uint, uint, uint) nothrow; + + /++ + Gets the block light level at the specified position relative to the chunk. + X and Z must be in the range [0, 15]. + +/ + ubyte getBlockLight(in BlockPos pos) @trusted nothrow { + auto _ret = __import_getBlockLight(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z)); + return cast(ubyte)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk.get-block-light") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk.get_block_light") + static private extern(C) uint __import_getBlockLight(uint, uint, uint, uint) nothrow; + + /++ + Sets a namespaced custom data value on this chunk. + +/ + void setCustomData(in WitString namespace, in WitString key, in NbtTree value) @trusted nothrow { + wit.common.DeallocateBuffer deallocate; + auto _listSrc28 = value.tags; + auto _list28 = _listSrc28.length ? wit.common.malloc(_listSrc28.length * ((8+2*size_t.sizeof))) : null; + assert(!_listSrc28.length || _list28); + if (_listSrc28.length) deallocate ~= _list28; + foreach (_elem0_idx, ref _elem0; _listSrc28) { + auto _base0 = _list28 + _elem0_idx * ((8+2*size_t.sizeof)); + alias _Tag27 = wit.pumpkin.plugin.common.imports.NbtTag.Tag; + final switch (_elem0.tag) { + case _Tag27.byte_: { + const ref byte _payload2 = _elem0.getByte(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(0); + *cast(ubyte*)(_base0 + 8) = cast(ubyte)(cast(uint)(_payload2)); + break; + } + case _Tag27.short_: { + const ref short _payload4 = _elem0.getShort(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(1); + *cast(ushort*)(_base0 + 8) = cast(ushort)(cast(uint)(_payload4)); + break; + } + case _Tag27.int_: { + const ref int _payload6 = _elem0.getInt(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(2); + *cast(uint*)(_base0 + 8) = cast(uint)(cast(uint)(_payload6)); + break; + } + case _Tag27.long_: { + const ref long _payload8 = _elem0.getLong(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(3); + *cast(ulong*)(_base0 + 8) = cast(ulong)(cast(ulong)(_payload8)); + break; + } + case _Tag27.float_: { + const ref float _payload10 = _elem0.getFloat(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(4); + *cast(float*)(_base0 + 8) = cast(float)(_payload10); + break; + } + case _Tag27.double_: { + const ref double _payload12 = _elem0.getDouble(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(5); + *cast(double*)(_base0 + 8) = cast(double)(_payload12); + break; + } + case _Tag27.byteArray: { + const ref WitList!(byte) _payload14 = _elem0.getByteArray(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(6); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload14.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload14.ptr)); + break; + } + case _Tag27.stringTag: { + const ref WitString _payload16 = _elem0.getStringTag(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(7); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload16.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload16.ptr)); + break; + } + case _Tag27.listTag: { + const ref WitList!(uint) _payload18 = _elem0.getListTag(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(8); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload18.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload18.ptr)); + break; + } + case _Tag27.compound: { + const ref WitList!(wit.pumpkin.plugin.common.imports.NbtEntry) _payload20 = _elem0.getCompound(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(9); + auto _listSrc22 = _payload20; + auto _list22 = _listSrc22.length ? wit.common.malloc(_listSrc22.length * ((3*size_t.sizeof))) : null; + assert(!_listSrc22.length || _list22); + if (_listSrc22.length) deallocate ~= _list22; + foreach (_elem21_idx, ref _elem21; _listSrc22) { + auto _base21 = _list22 + _elem21_idx * ((3*size_t.sizeof)); + *cast(size_t*)(_base21 + size_t.sizeof) = cast(size_t)(_elem21.key.length); + *cast(void**)(_base21 + 0) = cast(void*)(cast(void*)(_elem21.key.ptr)); + *cast(uint*)(_base21 + (2*size_t.sizeof)) = cast(uint)(_elem21.value); + + } + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload20.length); + *cast(void**)(_base0 + 8) = cast(void*)(_list22); + break; + } + case _Tag27.intArray: { + const ref WitList!(int) _payload24 = _elem0.getIntArray(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(10); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload24.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload24.ptr)); + break; + } + case _Tag27.longArray: { + const ref WitList!(long) _payload26 = _elem0.getLongArray(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(11); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload26.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload26.ptr)); + break; + } + } + + } + __import_setCustomData(this.__handle, cast(void*)(namespace.ptr), namespace.length, cast(void*)(key.ptr), key.length, value.root, _list28, value.tags.length); + deallocate.purge(); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk.set-custom-data") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk.set_custom_data") + static private extern(C) void __import_setCustomData(uint, void*, size_t, void*, size_t, uint, void*, size_t) nothrow; + + /++ + Returns a namespaced custom data value from this chunk, if set. + +/ + Option!(NbtTree) getCustomData(in WitString namespace, in WitString key) @trusted nothrow { + align(size_t.sizeof) void[(4*size_t.sizeof)] _retArea = void; + __import_getCustomData(this.__handle, cast(void*)(namespace.ptr), namespace.length, cast(void*)(key.ptr), key.length, _retArea.ptr); + Option!(NbtTree) _option47 = void; + bool _isSome47 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome47) { + auto _listSrcPtr44 = *(cast(void**)(_retArea.ptr + (2*size_t.sizeof))); + auto _listLen44 = *(cast(size_t*)(_retArea.ptr + (3*size_t.sizeof))); + auto _list44 = _listLen44 ? wit.common.mallocSlice!(wit.pumpkin.plugin.common.imports.NbtTag)(_listLen44) : []; + assert(!_listLen44 || _list44.ptr); + foreach (_elem2_idx, ref _elem2; _list44) { + const auto _base2 = _listSrcPtr44 + _elem2_idx * (8+2*size_t.sizeof); + wit.pumpkin.plugin.common.imports.NbtTag _variant31 = void; + auto _tag31 = cast(uint)(*(cast(ubyte*)(_base2 + 0))); + alias _Tag31 = wit.pumpkin.plugin.common.imports.NbtTag.Tag; + final switch (cast(wit.pumpkin.plugin.common.imports.NbtTag.Tag)_tag31) { + case _Tag31.byte_: { + auto _payload32 = cast(byte)(cast(uint)(*(cast(byte*)(_base2 + 8)))); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.byte_(_payload32); + break; + } + case _Tag31.short_: { + auto _payload33 = cast(short)(cast(uint)(*(cast(short*)(_base2 + 8)))); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.short_(_payload33); + break; + } + case _Tag31.int_: { + auto _payload34 = cast(int)(*(cast(uint*)(_base2 + 8))); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.int_(_payload34); + break; + } + case _Tag31.long_: { + auto _payload35 = cast(long)(*(cast(ulong*)(_base2 + 8))); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.long_(_payload35); + break; + } + case _Tag31.float_: { + auto _payload36 = *(cast(float*)(_base2 + 8)); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.float_(_payload36); + break; + } + case _Tag31.double_: { + auto _payload37 = *(cast(double*)(_base2 + 8)); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.double_(_payload37); + break; + } + case _Tag31.byteArray: { + auto _len10 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr10 = _len10 ? cast(byte*)(*(cast(void**)(_base2 + 8))) : null; + auto _list11 = WitList!(byte)(_ptr10[0.._len10]); + auto _payload38 = _list11; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.byteArray(_payload38); + break; + } + case _Tag31.stringTag: { + auto _len13 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr13 = _len13 ? cast(char*)(*(cast(void**)(_base2 + 8))) : null; + auto _list14 = WitString(_ptr13[0.._len13]); + auto _payload39 = _list14; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.stringTag(_payload39); + break; + } + case _Tag31.listTag: { + auto _len16 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr16 = _len16 ? cast(uint*)(*(cast(void**)(_base2 + 8))) : null; + auto _list17 = WitList!(uint)(_ptr16[0.._len16]); + auto _payload40 = _list17; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.listTag(_payload40); + break; + } + case _Tag31.compound: { + auto _listSrcPtr23 = *(cast(void**)(_base2 + 8)); + auto _listLen23 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _list23 = _listLen23 ? wit.common.mallocSlice!(wit.pumpkin.plugin.common.imports.NbtEntry)(_listLen23) : []; + assert(!_listLen23 || _list23.ptr); + foreach (_elem19_idx, ref _elem19; _list23) { + const auto _base19 = _listSrcPtr23 + _elem19_idx * (3*size_t.sizeof); + auto _len20 = *(cast(size_t*)(_base19 + size_t.sizeof)); + auto _ptr20 = _len20 ? cast(char*)(*(cast(void**)(_base19 + 0))) : null; + auto _list21 = WitString(_ptr20[0.._len20]); + wit.pumpkin.plugin.common.imports.NbtEntry _record22 = { + key: _list21, + value: *(cast(uint*)(_base19 + (2*size_t.sizeof))), + }; + _elem19 = _record22; + } + if (_listLen23) wit.common.free(_listSrcPtr23); + auto _witList24 = WitList!(wit.pumpkin.plugin.common.imports.NbtEntry)(_list23); + auto _payload41 = _witList24; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.compound(_payload41); + break; + } + case _Tag31.intArray: { + auto _len26 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr26 = _len26 ? cast(int*)(*(cast(void**)(_base2 + 8))) : null; + auto _list27 = WitList!(int)(_ptr26[0.._len26]); + auto _payload42 = _list27; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.intArray(_payload42); + break; + } + case _Tag31.longArray: { + auto _len29 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr29 = _len29 ? cast(long*)(*(cast(void**)(_base2 + 8))) : null; + auto _list30 = WitList!(long)(_ptr29[0.._len29]); + auto _payload43 = _list30; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.longArray(_payload43); + break; + } + } + _elem2 = _variant31; + } + if (_listLen44) wit.common.free(_listSrcPtr44); + auto _witList45 = WitList!(wit.pumpkin.plugin.common.imports.NbtTag)(_list44); + wit.pumpkin.plugin.common.imports.NbtTree _record46 = { + root: *(cast(uint*)(_retArea.ptr + size_t.sizeof)), + tags: _witList45, + }; + + _option47 = Option!(NbtTree).makeSome(_record46); + } else { + _option47 = Option!(NbtTree).makeNone; + } + auto _flush48 = _option47; + return _flush48; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk.get-custom-data") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk.get_custom_data") + static private extern(C) void __import_getCustomData(uint, void*, size_t, void*, size_t, void*) nothrow; + + /++ + Removes a namespaced custom data value from this chunk. + +/ + void removeCustomData(in WitString namespace, in WitString key) @trusted nothrow { + __import_removeCustomData(this.__handle, cast(void*)(namespace.ptr), namespace.length, cast(void*)(key.ptr), key.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk.remove-custom-data") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk.remove_custom_data") + static private extern(C) void __import_removeCustomData(uint, void*, size_t, void*, size_t) nothrow; + + /++ + Returns whether this chunk has a namespaced custom data value. + +/ + bool hasCustomData(in WitString namespace, in WitString key) @trusted nothrow { + auto _ret = __import_hasCustomData(this.__handle, cast(void*)(namespace.ptr), namespace.length, cast(void*)(key.ptr), key.length); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk.has-custom-data") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk.has_custom_data") + static private extern(C) uint __import_hasCustomData(uint, void*, size_t, void*, size_t) nothrow; + } +} + +/++ +Represents the boundaries of a world. ++/ +struct WorldBorder { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/world@0.1.0", "[resource-drop]world-border") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:resource_drop:world_border") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + Gets the center X coordinate of the border. + +/ + double getCenterX() @trusted nothrow { + auto _ret = __import_getCenterX(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world-border.get-center-x") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world_border.get_center_x") + static private extern(C) double __import_getCenterX(uint) nothrow; + + /++ + Gets the center Z coordinate of the border. + +/ + double getCenterZ() @trusted nothrow { + auto _ret = __import_getCenterZ(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world-border.get-center-z") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world_border.get_center_z") + static private extern(C) double __import_getCenterZ(uint) nothrow; + + /++ + Gets the center position of the border. + +/ + Position getCenter() @trusted nothrow { + align(8) void[24] _retArea = void; + __import_getCenter(this.__handle, _retArea.ptr); + auto _tuple0 = wit.pumpkin.plugin.common.imports.Position( + *(cast(double*)(_retArea.ptr + 0)), + *(cast(double*)(_retArea.ptr + 8)), + *(cast(double*)(_retArea.ptr + 16)), + ); + auto _flush1 = _tuple0; + return _flush1; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world-border.get-center") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world_border.get_center") + static private extern(C) void __import_getCenter(uint, void*) nothrow; + + /++ + Sets the center coordinates of the border. + +/ + void setCenter(double x, double z) @trusted nothrow { + __import_setCenter(this.__handle, x, z); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world-border.set-center") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world_border.set_center") + static private extern(C) void __import_setCenter(uint, double, double) nothrow; + + /++ + Gets the current diameter of the border. + +/ + double getDiameter() @trusted nothrow { + auto _ret = __import_getDiameter(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world-border.get-diameter") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world_border.get_diameter") + static private extern(C) double __import_getDiameter(uint) nothrow; + + /++ + Gets the current diameter of the border (alias for get-diameter). + +/ + double getSize() @trusted nothrow { + auto _ret = __import_getSize(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world-border.get-size") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world_border.get_size") + static private extern(C) double __import_getSize(uint) nothrow; + + /++ + Sets the diameter of the border, optionally with a speed (in ticks) for lerping. + +/ + void setDiameter(double diameter, in Option!(ulong) speed) @trusted nothrow { + uint _option4 = void; + ulong _option5 = void; + if (speed.isSome) { + ref _payload3 = speed.unwrap(); + _option4 = 1; + _option5 = _payload3; + } else { + _option4 = 0; + _option5 = 0; + } + __import_setDiameter(this.__handle, diameter, _option4, _option5); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world-border.set-diameter") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world_border.set_diameter") + static private extern(C) void __import_setDiameter(uint, double, uint, ulong) nothrow; + + /++ + Sets the size of the border instantly. + +/ + void setSize(double size) @trusted nothrow { + __import_setSize(this.__handle, size); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world-border.set-size") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world_border.set_size") + static private extern(C) void __import_setSize(uint, double) nothrow; + + /++ + Sets the size of the border with a transition duration in seconds. + +/ + void setSizeTransition(double newSize, ulong timeSeconds) @trusted nothrow { + __import_setSizeTransition(this.__handle, newSize, timeSeconds); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world-border.set-size-transition") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world_border.set_size_transition") + static private extern(C) void __import_setSizeTransition(uint, double, ulong) nothrow; + + /++ + Gets the target diameter when lerping/transitioning. + +/ + double getTargetDiameter() @trusted nothrow { + auto _ret = __import_getTargetDiameter(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world-border.get-target-diameter") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world_border.get_target_diameter") + static private extern(C) double __import_getTargetDiameter(uint) nothrow; + + /++ + Gets the target transition duration/speed in ticks. + +/ + long getTargetSpeed() @trusted nothrow { + auto _ret = __import_getTargetSpeed(this.__handle); + return cast(long)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world-border.get-target-speed") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world_border.get_target_speed") + static private extern(C) ulong __import_getTargetSpeed(uint) nothrow; + + /++ + Gets the distance from the border where warning effects start (in blocks). + +/ + int getWarningDistance() @trusted nothrow { + auto _ret = __import_getWarningDistance(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world-border.get-warning-distance") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world_border.get_warning_distance") + static private extern(C) uint __import_getWarningDistance(uint) nothrow; + + /++ + Sets the warning distance (in blocks). + +/ + void setWarningDistance(int distance) @trusted nothrow { + __import_setWarningDistance(this.__handle, cast(uint)(distance)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world-border.set-warning-distance") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world_border.set_warning_distance") + static private extern(C) void __import_setWarningDistance(uint, uint) nothrow; + + /++ + Gets the time before a player hitting the border is warned (in seconds). + +/ + int getWarningDelay() @trusted nothrow { + auto _ret = __import_getWarningDelay(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world-border.get-warning-delay") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world_border.get_warning_delay") + static private extern(C) uint __import_getWarningDelay(uint) nothrow; + + /++ + Sets the warning delay (in seconds). + +/ + void setWarningDelay(int delay) @trusted nothrow { + __import_setWarningDelay(this.__handle, cast(uint)(delay)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world-border.set-warning-delay") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world_border.set_warning_delay") + static private extern(C) void __import_setWarningDelay(uint, uint) nothrow; + + /++ + Gets the warning time (alias for get-warning-delay). + +/ + int getWarningTime() @trusted nothrow { + auto _ret = __import_getWarningTime(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world-border.get-warning-time") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world_border.get_warning_time") + static private extern(C) uint __import_getWarningTime(uint) nothrow; + + /++ + Sets the warning time (alias for set-warning-delay). + +/ + void setWarningTime(int time) @trusted nothrow { + __import_setWarningTime(this.__handle, cast(uint)(time)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world-border.set-warning-time") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world_border.set_warning_time") + static private extern(C) void __import_setWarningTime(uint, uint) nothrow; + + /++ + Gets the safe damage buffer distance outside the border (in blocks). + +/ + double getDamageBuffer() @trusted nothrow { + auto _ret = __import_getDamageBuffer(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world-border.get-damage-buffer") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world_border.get_damage_buffer") + static private extern(C) double __import_getDamageBuffer(uint) nothrow; + + /++ + Sets the safe damage buffer distance outside the border (in blocks). + +/ + void setDamageBuffer(double buffer) @trusted nothrow { + __import_setDamageBuffer(this.__handle, buffer); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world-border.set-damage-buffer") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world_border.set_damage_buffer") + static private extern(C) void __import_setDamageBuffer(uint, double) nothrow; + + /++ + Gets the damage amount inflicted per block per second when outside the buffer. + +/ + double getDamageAmount() @trusted nothrow { + auto _ret = __import_getDamageAmount(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world-border.get-damage-amount") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world_border.get_damage_amount") + static private extern(C) double __import_getDamageAmount(uint) nothrow; + + /++ + Sets the damage amount inflicted per block per second when outside the buffer. + +/ + void setDamageAmount(double damage) @trusted nothrow { + __import_setDamageAmount(this.__handle, damage); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world-border.set-damage-amount") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world_border.set_damage_amount") + static private extern(C) void __import_setDamageAmount(uint, double) nothrow; + + /++ + Returns whether the specified coordinates are within the border. + +/ + bool contains(double x, double z) @trusted nothrow { + auto _ret = __import_contains(this.__handle, x, z); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world-border.contains") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world_border.contains") + static private extern(C) uint __import_contains(uint, double, double) nothrow; + + /++ + Returns whether the specified position is within the border. + +/ + bool containsPos(in Position pos) @trusted nothrow { + auto _ret = __import_containsPos(this.__handle, pos[0], pos[1], pos[2]); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world-border.contains-pos") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world_border.contains_pos") + static private extern(C) uint __import_containsPos(uint, double, double, double) nothrow; + + /++ + Resets the world border to vanilla default settings. + +/ + void reset() @trusted nothrow { + __import_reset(this.__handle); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world-border.reset") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world_border.reset") + static private extern(C) void __import_reset(uint) nothrow; + } +} + +/++ +Represents a Minecraft world (dimension). ++/ +struct World { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/world@0.1.0", "[resource-drop]world") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:resource_drop:world") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + Returns the unique identifier of this world. + +/ + WitString getId() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getId(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-id") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_id") + static private extern(C) void __import_getId(uint, void*) nothrow; + + /++ + Gets the world border associated with this world (alias for get-world-border). + +/ + WorldBorder getBorder() @trusted nothrow { + auto _ret = __import_getBorder(this.__handle); + auto _handle0 = WorldBorder(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-border") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_border") + static private extern(C) uint __import_getBorder(uint) nothrow; + + /++ + Gets the world border associated with this world. + +/ + WorldBorder getWorldBorder() @trusted nothrow { + auto _ret = __import_getWorldBorder(this.__handle); + auto _handle0 = WorldBorder(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-world-border") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_world_border") + static private extern(C) uint __import_getWorldBorder(uint) nothrow; + + /++ + Gets the chunk at the specified chunk coordinates. + +/ + Option!(Chunk) getChunk(int x, int z) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getChunk(this.__handle, cast(uint)(x), cast(uint)(z), _retArea.ptr); + Option!(Chunk) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _handle2 = Chunk(*(cast(uint*)(_retArea.ptr + 4))); + + _option3 = Option!(Chunk).makeSome(_handle2); + } else { + _option3 = Option!(Chunk).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-chunk") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_chunk") + static private extern(C) void __import_getChunk(uint, uint, uint, void*) nothrow; + + /++ + Gets the block state ID at the specified position. + +/ + ushort getBlockStateId(in BlockPos pos) @trusted nothrow { + auto _ret = __import_getBlockStateId(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z)); + return cast(ushort)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-block-state-id") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_block_state_id") + static private extern(C) uint __import_getBlockStateId(uint, uint, uint, uint) nothrow; + + /++ + Gets detailed block state information at the specified position. + +/ + BlockState getBlockState(in BlockPos pos) @trusted nothrow { + align(size_t.sizeof) void[(32+10*size_t.sizeof)] _retArea = void; + __import_getBlockState(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z), _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _len2 = *(cast(size_t*)(_retArea.ptr + (24+4*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(BoundingBox*)(*(cast(void**)(_retArea.ptr + (24+3*size_t.sizeof)))) : null; + auto _list3 = WitList!(BoundingBox)(_ptr2[0.._len2]); + auto _len4 = *(cast(size_t*)(_retArea.ptr + (24+6*size_t.sizeof))); + auto _ptr4 = _len4 ? cast(BoundingBox*)(*(cast(void**)(_retArea.ptr + (24+5*size_t.sizeof)))) : null; + auto _list5 = WitList!(BoundingBox)(_ptr4[0.._len4]); + auto _listSrcPtr12 = *(cast(void**)(_retArea.ptr + (32+8*size_t.sizeof))); + auto _listLen12 = *(cast(size_t*)(_retArea.ptr + (32+9*size_t.sizeof))); + auto _list12 = _listLen12 ? wit.common.mallocSlice!(Tuple!(WitString, WitString))(_listLen12) : []; + assert(!_listLen12 || _list12.ptr); + foreach (_elem6_idx, ref _elem6; _list12) { + const auto _base6 = _listSrcPtr12 + _elem6_idx * (4*size_t.sizeof); + auto _len7 = *(cast(size_t*)(_base6 + size_t.sizeof)); + auto _ptr7 = _len7 ? cast(char*)(*(cast(void**)(_base6 + 0))) : null; + auto _list8 = WitString(_ptr7[0.._len7]); + auto _len9 = *(cast(size_t*)(_base6 + (3*size_t.sizeof))); + auto _ptr9 = _len9 ? cast(char*)(*(cast(void**)(_base6 + (2*size_t.sizeof)))) : null; + auto _list10 = WitString(_ptr9[0.._len9]); + auto _tuple11 = Tuple!(WitString, WitString)( + _list8, + _list10, + ); + _elem6 = _tuple11; + } + if (_listLen12) wit.common.free(_listSrcPtr12); + auto _witList13 = WitList!(Tuple!(WitString, WitString))(_list12); + BlockState _record14 = { + id: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + 0)))), + blockId: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + 2)))), + blockName: _list1, + luminance: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (3*size_t.sizeof))))), + opacity: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (1+3*size_t.sizeof))))), + hardness: *(cast(float*)(_retArea.ptr + (4+3*size_t.sizeof))), + isAir: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof))))) != 0, + isLiquid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (9+3*size_t.sizeof))))) != 0, + isSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (10+3*size_t.sizeof))))) != 0, + isFullCube: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (11+3*size_t.sizeof))))) != 0, + pistonBehavior: cast(PistonBehavior)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (12+3*size_t.sizeof))))), + hasRandomTicks: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (13+3*size_t.sizeof))))) != 0, + burnable: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (14+3*size_t.sizeof))))) != 0, + toolRequired: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (15+3*size_t.sizeof))))) != 0, + sidedTransparency: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (16+3*size_t.sizeof))))) != 0, + replaceable: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (17+3*size_t.sizeof))))) != 0, + isSolidBlock: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (18+3*size_t.sizeof))))) != 0, + blockEntityType: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + (20+3*size_t.sizeof))))), + instrument: cast(NoteblockInstrument)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (22+3*size_t.sizeof))))), + collisionShapes: _list3, + outlineShapes: _list5, + downSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (24+7*size_t.sizeof))))) != 0, + upSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (25+7*size_t.sizeof))))) != 0, + northSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (26+7*size_t.sizeof))))) != 0, + southSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (27+7*size_t.sizeof))))) != 0, + westSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (28+7*size_t.sizeof))))) != 0, + eastSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (29+7*size_t.sizeof))))) != 0, + downCenterSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (30+7*size_t.sizeof))))) != 0, + upCenterSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (31+7*size_t.sizeof))))) != 0, + mapColor: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (32+7*size_t.sizeof))))), + properties: _witList13, + }; + auto _flush15 = _record14; + return _flush15; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-block-state") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_block_state") + static private extern(C) void __import_getBlockState(uint, uint, uint, uint, void*) nothrow; + + /++ + Sets the block state at the specified position. + +/ + void setBlockState(in BlockPos pos, ushort state, BlockFlags updateFlags) @trusted nothrow { + __import_setBlockState(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z), cast(uint)(state), cast(uint)(updateFlags.bits)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.set-block-state") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.set_block_state") + static private extern(C) void __import_setBlockState(uint, uint, uint, uint, uint, uint) nothrow; + + /++ + Gets the block type at the specified position. + +/ + Block getBlock(in BlockPos pos) @trusted nothrow { + align(size_t.sizeof) void[(32+6*size_t.sizeof)] _retArea = void; + __import_getBlock(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z), _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _len2 = *(cast(size_t*)(_retArea.ptr + (24+5*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(ushort*)(*(cast(void**)(_retArea.ptr + (24+4*size_t.sizeof)))) : null; + auto _list3 = WitList!(ushort)(_ptr2[0.._len2]); + Option!(Flammable) _option7 = void; + bool _isSome7 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (27+6*size_t.sizeof))))) != 0; + if (_isSome7) { + Flammable _record6 = { + spreadChance: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (28+6*size_t.sizeof))))), + burnChance: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (29+6*size_t.sizeof))))), + }; + + _option7 = Option!(Flammable).makeSome(_record6); + } else { + _option7 = Option!(Flammable).makeNone; + } + Block _record8 = { + id: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + 0)))), + name: _list1, + hardness: *(cast(float*)(_retArea.ptr + (3*size_t.sizeof))), + blastResistance: *(cast(float*)(_retArea.ptr + (4+3*size_t.sizeof))), + mapColor: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof))))), + slipperiness: *(cast(float*)(_retArea.ptr + (12+3*size_t.sizeof))), + velocityMultiplier: *(cast(float*)(_retArea.ptr + (16+3*size_t.sizeof))), + jumpVelocityMultiplier: *(cast(float*)(_retArea.ptr + (20+3*size_t.sizeof))), + itemId: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + (24+3*size_t.sizeof))))), + defaultStateId: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + (26+3*size_t.sizeof))))), + stateIds: _list3, + isSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (24+6*size_t.sizeof))))) != 0, + isAir: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (25+6*size_t.sizeof))))) != 0, + isFlammable: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (26+6*size_t.sizeof))))) != 0, + flammable: _option7, + }; + auto _flush9 = _record8; + return _flush9; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-block") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_block") + static private extern(C) void __import_getBlock(uint, uint, uint, uint, void*) nothrow; + + /++ + Gets the numerical block ID at the specified position. + +/ + ushort getBlockId(in BlockPos pos) @trusted nothrow { + auto _ret = __import_getBlockId(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z)); + return cast(ushort)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-block-id") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_block_id") + static private extern(C) uint __import_getBlockId(uint, uint, uint, uint) nothrow; + + /++ + Sets the block at the specified position using its default state. + +/ + void setBlock(in BlockPos pos, in Block block, BlockFlags updateFlags) @trusted nothrow { + align(size_t.sizeof) void[(48+7*size_t.sizeof)] _retArea = void; + *cast(uint*)(_retArea.ptr + 0) = cast(uint)(this.__handle); + *cast(uint*)(_retArea.ptr + 4) = cast(uint)(cast(uint)(pos.x)); + *cast(uint*)(_retArea.ptr + 8) = cast(uint)(cast(uint)(pos.y)); + *cast(uint*)(_retArea.ptr + 12) = cast(uint)(cast(uint)(pos.z)); + *cast(ushort*)(_retArea.ptr + 16) = cast(ushort)(cast(uint)(block.id)); + *cast(size_t*)(_retArea.ptr + (16+2*size_t.sizeof)) = cast(size_t)(block.name.length); + *cast(void**)(_retArea.ptr + (16+1*size_t.sizeof)) = cast(void*)(cast(void*)(block.name.ptr)); + *cast(float*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(float)(block.hardness); + *cast(float*)(_retArea.ptr + (20+3*size_t.sizeof)) = cast(float)(block.blastResistance); + *cast(ubyte*)(_retArea.ptr + (24+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(block.mapColor)); + *cast(float*)(_retArea.ptr + (28+3*size_t.sizeof)) = cast(float)(block.slipperiness); + *cast(float*)(_retArea.ptr + (32+3*size_t.sizeof)) = cast(float)(block.velocityMultiplier); + *cast(float*)(_retArea.ptr + (36+3*size_t.sizeof)) = cast(float)(block.jumpVelocityMultiplier); + *cast(ushort*)(_retArea.ptr + (40+3*size_t.sizeof)) = cast(ushort)(cast(uint)(block.itemId)); + *cast(ushort*)(_retArea.ptr + (42+3*size_t.sizeof)) = cast(ushort)(cast(uint)(block.defaultStateId)); + *cast(size_t*)(_retArea.ptr + (40+5*size_t.sizeof)) = cast(size_t)(block.stateIds.length); + *cast(void**)(_retArea.ptr + (40+4*size_t.sizeof)) = cast(void*)(cast(void*)(block.stateIds.ptr)); + *cast(ubyte*)(_retArea.ptr + (40+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(block.isSolid)); + *cast(ubyte*)(_retArea.ptr + (41+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(block.isAir)); + *cast(ubyte*)(_retArea.ptr + (42+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(block.isFlammable)); + if (block.flammable.isSome) { + ref _payload3 = block.flammable.unwrap(); + *cast(ubyte*)(_retArea.ptr + (43+6*size_t.sizeof)) = cast(ubyte)(1); + *cast(ubyte*)(_retArea.ptr + (44+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload3.spreadChance)); + *cast(ubyte*)(_retArea.ptr + (45+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload3.burnChance)); + } else { + *cast(ubyte*)(_retArea.ptr + (43+6*size_t.sizeof)) = cast(ubyte)(0); + } + *cast(ubyte*)(_retArea.ptr + (48+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(updateFlags.bits)); + __import_setBlock(_retArea.ptr); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.set-block") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.set_block") + static private extern(C) void __import_setBlock(void*) nothrow; + + /++ + Sets the block at the specified position by numerical block ID using its default state. + +/ + void setBlockById(in BlockPos pos, ushort blockId, BlockFlags updateFlags) @trusted nothrow { + __import_setBlockById(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z), cast(uint)(blockId), cast(uint)(updateFlags.bits)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.set-block-by-id") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.set_block_by_id") + static private extern(C) void __import_setBlockById(uint, uint, uint, uint, uint, uint) nothrow; + + /++ + Sets the block at the specified position by namespaced name using its default state. + Returns true if the block was recognized and set. + +/ + bool setBlockByName(in BlockPos pos, in WitString name, BlockFlags updateFlags) @trusted nothrow { + auto _ret = __import_setBlockByName(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z), cast(void*)(name.ptr), name.length, cast(uint)(updateFlags.bits)); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.set-block-by-name") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.set_block_by_name") + static private extern(C) uint __import_setBlockByName(uint, uint, uint, uint, void*, size_t, uint) nothrow; + + /++ + Returns the current time of day in ticks. + +/ + ulong getTimeOfDay() @trusted nothrow { + auto _ret = __import_getTimeOfDay(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-time-of-day") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_time_of_day") + static private extern(C) ulong __import_getTimeOfDay(uint) nothrow; + + /++ + Sets the current time of day in ticks. + +/ + void setTimeOfDay(ulong time) @trusted nothrow { + __import_setTimeOfDay(this.__handle, time); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.set-time-of-day") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.set_time_of_day") + static private extern(C) void __import_setTimeOfDay(uint, ulong) nothrow; + + /++ + Returns the total age of the world in ticks. + +/ + ulong getWorldAge() @trusted nothrow { + auto _ret = __import_getWorldAge(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-world-age") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_world_age") + static private extern(C) ulong __import_getWorldAge(uint) nothrow; + + /++ + Returns the dimension type (e.g., \"minecraft:overworld\"). + +/ + WitString getDimension() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getDimension(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-dimension") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_dimension") + static private extern(C) void __import_getDimension(uint, void*) nothrow; + + /++ + Returns the configured shared spawn location for this world. + +/ + WorldSpawnLocation getSpawnLocation() @trusted nothrow { + align(4) void[20] _retArea = void; + __import_getSpawnLocation(this.__handle, _retArea.ptr); + wit.pumpkin.plugin.common.imports.BlockPos _record0 = { + x: cast(int)(*(cast(uint*)(_retArea.ptr + 0))), + y: cast(int)(*(cast(uint*)(_retArea.ptr + 4))), + z: cast(int)(*(cast(uint*)(_retArea.ptr + 8))), + }; + WorldSpawnLocation _record1 = { + pos: _record0, + yaw: *(cast(float*)(_retArea.ptr + 12)), + pitch: *(cast(float*)(_retArea.ptr + 16)), + }; + auto _flush2 = _record1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-spawn-location") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_spawn_location") + static private extern(C) void __import_getSpawnLocation(uint, void*) nothrow; + + /++ + Gets the highest non-air block Y coordinate at the specified X and Z. + +/ + int getTopBlockY(int x, int z) @trusted nothrow { + auto _ret = __import_getTopBlockY(this.__handle, cast(uint)(x), cast(uint)(z)); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-top-block-y") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_top_block_y") + static private extern(C) uint __import_getTopBlockY(uint, uint, uint) nothrow; + + /++ + Gets the highest motion-blocking block Y coordinate. + +/ + int getMotionBlockingHeight(int x, int z) @trusted nothrow { + auto _ret = __import_getMotionBlockingHeight(this.__handle, cast(uint)(x), cast(uint)(z)); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-motion-blocking-height") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_motion_blocking_height") + static private extern(C) uint __import_getMotionBlockingHeight(uint, uint, uint) nothrow; + + /++ + Returns whether it is currently raining or snowing. + +/ + bool isRaining() @trusted nothrow { + auto _ret = __import_isRaining(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.is-raining") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.is_raining") + static private extern(C) uint __import_isRaining(uint) nothrow; + + /++ + Sets whether it should be raining or snowing. + +/ + void setRaining(bool raining) @trusted nothrow { + __import_setRaining(this.__handle, cast(uint)(raining)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.set-raining") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.set_raining") + static private extern(C) void __import_setRaining(uint, uint) nothrow; + + /++ + Returns whether there is currently a thunderstorm. + +/ + bool isThundering() @trusted nothrow { + auto _ret = __import_isThundering(this.__handle); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.is-thundering") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.is_thundering") + static private extern(C) uint __import_isThundering(uint) nothrow; + + /++ + Sets whether there should be a thunderstorm. + +/ + void setThundering(bool thundering) @trusted nothrow { + __import_setThundering(this.__handle, cast(uint)(thundering)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.set-thundering") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.set_thundering") + static private extern(C) void __import_setThundering(uint, uint) nothrow; + + /++ + Broadcasts a system message to all players in this world. + +/ + void broadcastSystemMessage(TextComponent message, bool overlay) @trusted nothrow { + __import_broadcastSystemMessage(this.__handle, message.__handle, cast(uint)(overlay)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.broadcast-system-message") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.broadcast_system_message") + static private extern(C) void __import_broadcastSystemMessage(uint, uint, uint) nothrow; + + /++ + Returns the scoreboard associated with this world. + +/ + Scoreboard getScoreboard() @trusted nothrow { + auto _ret = __import_getScoreboard(this.__handle); + auto _handle0 = Scoreboard(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-scoreboard") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_scoreboard") + static private extern(C) uint __import_getScoreboard(uint) nothrow; + + /++ + Plays a sound at the specified position for all players in the world. + +/ + void playSound(Sound sound, SoundCategory category, in Position pos, float volume, float pitch) @trusted nothrow { + __import_playSound(this.__handle, cast(uint)(sound), cast(uint)(category), pos[0], pos[1], pos[2], volume, pitch); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.play-sound") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.play_sound") + static private extern(C) void __import_playSound(uint, uint, uint, double, double, double, float, float) nothrow; + + /++ + Plays a custom resource pack sound identifier at the specified position for all players in the world. + +/ + void playCustomSound(in WitString soundName, SoundCategory category, in Position pos, float volume, float pitch) @trusted nothrow { + __import_playCustomSound(this.__handle, cast(void*)(soundName.ptr), soundName.length, cast(uint)(category), pos[0], pos[1], pos[2], volume, pitch); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.play-custom-sound") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.play_custom_sound") + static private extern(C) void __import_playCustomSound(uint, void*, size_t, uint, double, double, double, float, float) nothrow; + + /++ + Spawns particles at the specified position. + +/ + void spawnParticle(Particle particle, in Position pos, in Position offset, float maxSpeed, int count) @trusted nothrow { + __import_spawnParticle(this.__handle, cast(uint)(particle), pos[0], pos[1], pos[2], offset[0], offset[1], offset[2], maxSpeed, cast(uint)(count)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.spawn-particle") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.spawn_particle") + static private extern(C) void __import_spawnParticle(uint, uint, double, double, double, double, double, double, float, uint) nothrow; + + /++ + Creates an explosion at the specified position. + +/ + void createExplosion(in Position pos, float power, bool createFire, ExplosionInteraction interaction) @trusted nothrow { + __import_createExplosion(this.__handle, pos[0], pos[1], pos[2], power, cast(uint)(createFire), cast(uint)(interaction)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.create-explosion") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.create_explosion") + static private extern(C) void __import_createExplosion(uint, double, double, double, float, uint, uint) nothrow; + + /++ + Returns the sea level of this world. + +/ + int getSeaLevel() @trusted nothrow { + auto _ret = __import_getSeaLevel(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-sea-level") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_sea_level") + static private extern(C) uint __import_getSeaLevel(uint) nothrow; + + /++ + Returns the minimum Y coordinate (bottom of the world). + +/ + int getMinY() @trusted nothrow { + auto _ret = __import_getMinY(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-min-y") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_min_y") + static private extern(C) uint __import_getMinY(uint) nothrow; + + /++ + Returns the sky light level at the specified position. + +/ + ubyte getSkyLight(in BlockPos pos) @trusted nothrow { + auto _ret = __import_getSkyLight(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z)); + return cast(ubyte)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-sky-light") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_sky_light") + static private extern(C) uint __import_getSkyLight(uint, uint, uint, uint) nothrow; + + /++ + Sets the sky light level at the specified position. + +/ + void setSkyLight(in BlockPos pos, ubyte level) @trusted nothrow { + __import_setSkyLight(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z), cast(uint)(level)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.set-sky-light") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.set_sky_light") + static private extern(C) void __import_setSkyLight(uint, uint, uint, uint, uint) nothrow; + + /++ + Returns the block light level at the specified position. + +/ + ubyte getBlockLight(in BlockPos pos) @trusted nothrow { + auto _ret = __import_getBlockLight(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z)); + return cast(ubyte)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-block-light") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_block_light") + static private extern(C) uint __import_getBlockLight(uint, uint, uint, uint) nothrow; + + /++ + Sets the block light level at the specified position. + +/ + void setBlockLight(in BlockPos pos, ubyte level) @trusted nothrow { + __import_setBlockLight(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z), cast(uint)(level)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.set-block-light") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.set_block_light") + static private extern(C) void __import_setBlockLight(uint, uint, uint, uint, uint) nothrow; + + /++ + Returns the biome at the specified position. + +/ + Biome getBiome(in BlockPos pos) @trusted nothrow { + auto _ret = __import_getBiome(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z)); + return cast(wit.pumpkin.plugin.biomes.imports.Biome)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-biome") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_biome") + static private extern(C) uint __import_getBiome(uint, uint, uint, uint) nothrow; + + /++ + Spawns an entity of the specified type at the given position. + +/ + Entity spawnEntity(EntityType entityType, in Position pos) @trusted nothrow { + auto _ret = __import_spawnEntity(this.__handle, cast(uint)(entityType), pos[0], pos[1], pos[2]); + auto _handle0 = Entity(_ret); + return _handle0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.spawn-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.spawn_entity") + static private extern(C) uint __import_spawnEntity(uint, uint, double, double, double) nothrow; + + /++ + Returns a list of all entities in this world. + +/ + WitList!(Entity) getEntities() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getEntities(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(Entity*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitList!(Entity)(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-entities") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_entities") + static private extern(C) void __import_getEntities(uint, void*) nothrow; + + /++ + Spawns a lightning bolt at the specified position. + +/ + void strikeLightning(in Position pos, bool effectOnly) @trusted nothrow { + __import_strikeLightning(this.__handle, pos[0], pos[1], pos[2], cast(uint)(effectOnly)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.strike-lightning") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.strike_lightning") + static private extern(C) void __import_strikeLightning(uint, double, double, double, uint) nothrow; + + /++ + Performs a raycast from start position to end position to hit blocks. + +/ + Option!(Position) rayTraceBlocks(in Position start, in Position end) @trusted nothrow { + align(8) void[32] _retArea = void; + __import_rayTraceBlocks(this.__handle, start[0], start[1], start[2], end[0], end[1], end[2], _retArea.ptr); + Option!(Position) _option3 = void; + bool _isSome3 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome3) { + auto _tuple2 = wit.pumpkin.plugin.common.imports.Position( + *(cast(double*)(_retArea.ptr + 8)), + *(cast(double*)(_retArea.ptr + 16)), + *(cast(double*)(_retArea.ptr + 24)), + ); + + _option3 = Option!(Position).makeSome(_tuple2); + } else { + _option3 = Option!(Position).makeNone; + } + auto _flush4 = _option3; + return _flush4; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.ray-trace-blocks") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.ray_trace_blocks") + static private extern(C) void __import_rayTraceBlocks(uint, double, double, double, double, double, double, void*) nothrow; + + /++ + Performs a raycast from start position to end position to hit blocks, with optional fluid handling. + +/ + Option!(RayTraceBlockResult) rayTraceBlock(in Position start, in Position end, bool includeFluids) @trusted nothrow { + align(8) void[48] _retArea = void; + __import_rayTraceBlock(this.__handle, start[0], start[1], start[2], end[0], end[1], end[2], cast(uint)(includeFluids), _retArea.ptr); + Option!(RayTraceBlockResult) _option5 = void; + bool _isSome5 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome5) { + wit.pumpkin.plugin.common.imports.BlockPos _record2 = { + x: cast(int)(*(cast(uint*)(_retArea.ptr + 8))), + y: cast(int)(*(cast(uint*)(_retArea.ptr + 12))), + z: cast(int)(*(cast(uint*)(_retArea.ptr + 16))), + }; + auto _tuple3 = wit.pumpkin.plugin.common.imports.Position( + *(cast(double*)(_retArea.ptr + 24)), + *(cast(double*)(_retArea.ptr + 32)), + *(cast(double*)(_retArea.ptr + 40)), + ); + RayTraceBlockResult _record4 = { + pos: _record2, + face: cast(BlockDirection)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + 20)))), + hitPos: _tuple3, + }; + + _option5 = Option!(RayTraceBlockResult).makeSome(_record4); + } else { + _option5 = Option!(RayTraceBlockResult).makeNone; + } + auto _flush6 = _option5; + return _flush6; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.ray-trace-block") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.ray_trace_block") + static private extern(C) void __import_rayTraceBlock(uint, double, double, double, double, double, double, uint, void*) nothrow; + + /++ + Performs a raycast from start position to end position to find the closest entity hit. + +/ + Option!(RayTraceEntityResult) rayTraceEntity(in Position start, in Position end) @trusted nothrow { + align(8) void[48] _retArea = void; + __import_rayTraceEntity(this.__handle, start[0], start[1], start[2], end[0], end[1], end[2], _retArea.ptr); + Option!(RayTraceEntityResult) _option5 = void; + bool _isSome5 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome5) { + auto _handle2 = Entity(*(cast(uint*)(_retArea.ptr + 8))); + auto _tuple3 = wit.pumpkin.plugin.common.imports.Position( + *(cast(double*)(_retArea.ptr + 16)), + *(cast(double*)(_retArea.ptr + 24)), + *(cast(double*)(_retArea.ptr + 32)), + ); + RayTraceEntityResult _record4 = { + entity: _handle2, + hitPos: _tuple3, + distance: *(cast(double*)(_retArea.ptr + 40)), + }; + + _option5 = Option!(RayTraceEntityResult).makeSome(_record4); + } else { + _option5 = Option!(RayTraceEntityResult).makeNone; + } + auto _flush6 = _option5; + return _flush6; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.ray-trace-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.ray_trace_entity") + static private extern(C) void __import_rayTraceEntity(uint, double, double, double, double, double, double, void*) nothrow; + + /++ + Performs a raycast from start position to end position to find all entities hit along the ray. + +/ + WitList!(RayTraceEntityResult) rayTraceEntities(in Position start, in Position end) @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_rayTraceEntities(this.__handle, start[0], start[1], start[2], end[0], end[1], end[2], _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(RayTraceEntityResult*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitList!(RayTraceEntityResult)(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.ray-trace-entities") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.ray_trace_entities") + static private extern(C) void __import_rayTraceEntities(uint, double, double, double, double, double, double, void*) nothrow; + + /++ + Returns the block entity at the specified position, if any. + +/ + Option!(BlockEntityType) getBlockEntity(in BlockPos pos) @trusted nothrow { + align(4) void[12] _retArea = void; + __import_getBlockEntity(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z), _retArea.ptr); + Option!(BlockEntityType) _option159 = void; + bool _isSome159 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome159) { + wit.pumpkin.plugin.block_entity.imports.BlockEntityType _variant106 = void; + auto _tag106 = cast(uint)(*(cast(ubyte*)(_retArea.ptr + 4))); + alias _Tag106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.Tag; + final switch (cast(wit.pumpkin.plugin.block_entity.imports.BlockEntityType.Tag)_tag106) { + case _Tag106.commandBlockEntity: { + auto _handle3 = wit.pumpkin.plugin.block_entity.imports.CommandBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload107 = _handle3; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.commandBlockEntity(_payload107); + break; + } + case _Tag106.signBlockEntity: { + auto _handle5 = wit.pumpkin.plugin.block_entity.imports.SignBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload108 = _handle5; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.signBlockEntity(_payload108); + break; + } + case _Tag106.hangingSignBlockEntity: { + auto _handle7 = wit.pumpkin.plugin.block_entity.imports.HangingSignBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload109 = _handle7; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.hangingSignBlockEntity(_payload109); + break; + } + case _Tag106.jukeboxBlockEntity: { + auto _handle9 = wit.pumpkin.plugin.block_entity.imports.JukeboxBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload110 = _handle9; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.jukeboxBlockEntity(_payload110); + break; + } + case _Tag106.chestBlockEntity: { + auto _handle11 = wit.pumpkin.plugin.block_entity.imports.ChestBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload111 = _handle11; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.chestBlockEntity(_payload111); + break; + } + case _Tag106.trappedChestBlockEntity: { + auto _handle13 = wit.pumpkin.plugin.block_entity.imports.TrappedChestBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload112 = _handle13; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.trappedChestBlockEntity(_payload112); + break; + } + case _Tag106.mobSpawnerBlockEntity: { + auto _handle15 = wit.pumpkin.plugin.block_entity.imports.MobSpawnerBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload113 = _handle15; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.mobSpawnerBlockEntity(_payload113); + break; + } + case _Tag106.mapBlockEntity: { + auto _handle17 = wit.pumpkin.plugin.block_entity.imports.MapBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload114 = _handle17; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.mapBlockEntity(_payload114); + break; + } + case _Tag106.bannerBlockEntity: { + auto _handle19 = wit.pumpkin.plugin.block_entity.imports.BannerBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload115 = _handle19; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.bannerBlockEntity(_payload115); + break; + } + case _Tag106.barrelBlockEntity: { + auto _handle21 = wit.pumpkin.plugin.block_entity.imports.BarrelBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload116 = _handle21; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.barrelBlockEntity(_payload116); + break; + } + case _Tag106.beaconBlockEntity: { + auto _handle23 = wit.pumpkin.plugin.block_entity.imports.BeaconBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload117 = _handle23; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.beaconBlockEntity(_payload117); + break; + } + case _Tag106.bedBlockEntity: { + auto _handle25 = wit.pumpkin.plugin.block_entity.imports.BedBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload118 = _handle25; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.bedBlockEntity(_payload118); + break; + } + case _Tag106.beehiveBlockEntity: { + auto _handle27 = wit.pumpkin.plugin.block_entity.imports.BeehiveBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload119 = _handle27; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.beehiveBlockEntity(_payload119); + break; + } + case _Tag106.bellBlockEntity: { + auto _handle29 = wit.pumpkin.plugin.block_entity.imports.BellBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload120 = _handle29; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.bellBlockEntity(_payload120); + break; + } + case _Tag106.blastingFurnaceBlockEntity: { + auto _handle31 = wit.pumpkin.plugin.block_entity.imports.BlastingFurnaceBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload121 = _handle31; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.blastingFurnaceBlockEntity(_payload121); + break; + } + case _Tag106.brewingStandBlockEntity: { + auto _handle33 = wit.pumpkin.plugin.block_entity.imports.BrewingStandBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload122 = _handle33; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.brewingStandBlockEntity(_payload122); + break; + } + case _Tag106.brushableBlockBlockEntity: { + auto _handle35 = wit.pumpkin.plugin.block_entity.imports.BrushableBlockBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload123 = _handle35; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.brushableBlockBlockEntity(_payload123); + break; + } + case _Tag106.calibratedSculkSensorBlockEntity: { + auto _handle37 = wit.pumpkin.plugin.block_entity.imports.CalibratedSculkSensorBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload124 = _handle37; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.calibratedSculkSensorBlockEntity(_payload124); + break; + } + case _Tag106.campfireBlockEntity: { + auto _handle39 = wit.pumpkin.plugin.block_entity.imports.CampfireBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload125 = _handle39; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.campfireBlockEntity(_payload125); + break; + } + case _Tag106.chiseledBookshelfBlockEntity: { + auto _handle41 = wit.pumpkin.plugin.block_entity.imports.ChiseledBookshelfBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload126 = _handle41; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.chiseledBookshelfBlockEntity(_payload126); + break; + } + case _Tag106.comparatorBlockEntity: { + auto _handle43 = wit.pumpkin.plugin.block_entity.imports.ComparatorBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload127 = _handle43; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.comparatorBlockEntity(_payload127); + break; + } + case _Tag106.conduitBlockEntity: { + auto _handle45 = wit.pumpkin.plugin.block_entity.imports.ConduitBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload128 = _handle45; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.conduitBlockEntity(_payload128); + break; + } + case _Tag106.copperGolemStatueBlockEntity: { + auto _handle47 = wit.pumpkin.plugin.block_entity.imports.CopperGolemStatueBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload129 = _handle47; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.copperGolemStatueBlockEntity(_payload129); + break; + } + case _Tag106.crafterBlockEntity: { + auto _handle49 = wit.pumpkin.plugin.block_entity.imports.CrafterBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload130 = _handle49; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.crafterBlockEntity(_payload130); + break; + } + case _Tag106.creakingHeartBlockEntity: { + auto _handle51 = wit.pumpkin.plugin.block_entity.imports.CreakingHeartBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload131 = _handle51; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.creakingHeartBlockEntity(_payload131); + break; + } + case _Tag106.daylightDetectorBlockEntity: { + auto _handle53 = wit.pumpkin.plugin.block_entity.imports.DaylightDetectorBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload132 = _handle53; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.daylightDetectorBlockEntity(_payload132); + break; + } + case _Tag106.decoratedPotBlockEntity: { + auto _handle55 = wit.pumpkin.plugin.block_entity.imports.DecoratedPotBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload133 = _handle55; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.decoratedPotBlockEntity(_payload133); + break; + } + case _Tag106.dispenserBlockEntity: { + auto _handle57 = wit.pumpkin.plugin.block_entity.imports.DispenserBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload134 = _handle57; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.dispenserBlockEntity(_payload134); + break; + } + case _Tag106.dropperBlockEntity: { + auto _handle59 = wit.pumpkin.plugin.block_entity.imports.DropperBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload135 = _handle59; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.dropperBlockEntity(_payload135); + break; + } + case _Tag106.enchantingTableBlockEntity: { + auto _handle61 = wit.pumpkin.plugin.block_entity.imports.EnchantingTableBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload136 = _handle61; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.enchantingTableBlockEntity(_payload136); + break; + } + case _Tag106.endGatewayBlockEntity: { + auto _handle63 = wit.pumpkin.plugin.block_entity.imports.EndGatewayBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload137 = _handle63; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.endGatewayBlockEntity(_payload137); + break; + } + case _Tag106.endPortalBlockEntity: { + auto _handle65 = wit.pumpkin.plugin.block_entity.imports.EndPortalBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload138 = _handle65; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.endPortalBlockEntity(_payload138); + break; + } + case _Tag106.enderChestBlockEntity: { + auto _handle67 = wit.pumpkin.plugin.block_entity.imports.EnderChestBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload139 = _handle67; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.enderChestBlockEntity(_payload139); + break; + } + case _Tag106.furnaceBlockEntity: { + auto _handle69 = wit.pumpkin.plugin.block_entity.imports.FurnaceBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload140 = _handle69; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.furnaceBlockEntity(_payload140); + break; + } + case _Tag106.hopperBlockEntity: { + auto _handle71 = wit.pumpkin.plugin.block_entity.imports.HopperBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload141 = _handle71; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.hopperBlockEntity(_payload141); + break; + } + case _Tag106.jigsawBlockEntity: { + auto _handle73 = wit.pumpkin.plugin.block_entity.imports.JigsawBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload142 = _handle73; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.jigsawBlockEntity(_payload142); + break; + } + case _Tag106.lecternBlockEntity: { + auto _handle75 = wit.pumpkin.plugin.block_entity.imports.LecternBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload143 = _handle75; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.lecternBlockEntity(_payload143); + break; + } + case _Tag106.pistonBlockEntity: { + auto _handle77 = wit.pumpkin.plugin.block_entity.imports.PistonBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload144 = _handle77; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.pistonBlockEntity(_payload144); + break; + } + case _Tag106.potentSulfurBlockEntity: { + auto _handle79 = wit.pumpkin.plugin.block_entity.imports.PotentSulfurBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload145 = _handle79; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.potentSulfurBlockEntity(_payload145); + break; + } + case _Tag106.sculkCatalystBlockEntity: { + auto _handle81 = wit.pumpkin.plugin.block_entity.imports.SculkCatalystBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload146 = _handle81; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.sculkCatalystBlockEntity(_payload146); + break; + } + case _Tag106.sculkSensorBlockEntity: { + auto _handle83 = wit.pumpkin.plugin.block_entity.imports.SculkSensorBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload147 = _handle83; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.sculkSensorBlockEntity(_payload147); + break; + } + case _Tag106.sculkShriekerBlockEntity: { + auto _handle85 = wit.pumpkin.plugin.block_entity.imports.SculkShriekerBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload148 = _handle85; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.sculkShriekerBlockEntity(_payload148); + break; + } + case _Tag106.shelfBlockEntity: { + auto _handle87 = wit.pumpkin.plugin.block_entity.imports.ShelfBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload149 = _handle87; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.shelfBlockEntity(_payload149); + break; + } + case _Tag106.shulkerBoxBlockEntity: { + auto _handle89 = wit.pumpkin.plugin.block_entity.imports.ShulkerBoxBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload150 = _handle89; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.shulkerBoxBlockEntity(_payload150); + break; + } + case _Tag106.skullBlockEntity: { + auto _handle91 = wit.pumpkin.plugin.block_entity.imports.SkullBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload151 = _handle91; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.skullBlockEntity(_payload151); + break; + } + case _Tag106.smokerBlockEntity: { + auto _handle93 = wit.pumpkin.plugin.block_entity.imports.SmokerBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload152 = _handle93; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.smokerBlockEntity(_payload152); + break; + } + case _Tag106.structureBlockBlockEntity: { + auto _handle95 = wit.pumpkin.plugin.block_entity.imports.StructureBlockBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload153 = _handle95; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.structureBlockBlockEntity(_payload153); + break; + } + case _Tag106.testBlockBlockEntity: { + auto _handle97 = wit.pumpkin.plugin.block_entity.imports.TestBlockBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload154 = _handle97; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.testBlockBlockEntity(_payload154); + break; + } + case _Tag106.testInstanceBlockBlockEntity: { + auto _handle99 = wit.pumpkin.plugin.block_entity.imports.TestInstanceBlockBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload155 = _handle99; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.testInstanceBlockBlockEntity(_payload155); + break; + } + case _Tag106.trialSpawnerBlockEntity: { + auto _handle101 = wit.pumpkin.plugin.block_entity.imports.TrialSpawnerBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload156 = _handle101; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.trialSpawnerBlockEntity(_payload156); + break; + } + case _Tag106.vaultBlockEntity: { + auto _handle103 = wit.pumpkin.plugin.block_entity.imports.VaultBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload157 = _handle103; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.vaultBlockEntity(_payload157); + break; + } + case _Tag106.containerBlockEntity: { + auto _handle105 = wit.pumpkin.plugin.block_entity.imports.ContainerBlockEntity(*(cast(uint*)(_retArea.ptr + 8))); + auto _payload158 = _handle105; + _variant106 = wit.pumpkin.plugin.block_entity.imports.BlockEntityType.containerBlockEntity(_payload158); + break; + } + } + + _option159 = Option!(BlockEntityType).makeSome(_variant106); + } else { + _option159 = Option!(BlockEntityType).makeNone; + } + auto _flush160 = _option159; + return _flush160; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-block-entity") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_block_entity") + static private extern(C) void __import_getBlockEntity(uint, uint, uint, uint, void*) nothrow; + + /++ + Returns the raw NBT bytes of the block entity at the given position, if any. + +/ + Option!(WitList!(ubyte)) getBlockEntityNbt(in BlockPos pos) @trusted nothrow { + align(size_t.sizeof) void[(3*size_t.sizeof)] _retArea = void; + __import_getBlockEntityNbt(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z), _retArea.ptr); + Option!(WitList!(ubyte)) _option4 = void; + bool _isSome4 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome4) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(ubyte*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list3 = WitList!(ubyte)(_ptr2[0.._len2]); + + _option4 = Option!(WitList!(ubyte)).makeSome(_list3); + } else { + _option4 = Option!(WitList!(ubyte)).makeNone; + } + auto _flush5 = _option4; + return _flush5; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-block-entity-nbt") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_block_entity_nbt") + static private extern(C) void __import_getBlockEntityNbt(uint, uint, uint, uint, void*) nothrow; + + /++ + Restores a block entity from raw NBT bytes at the given position. + The NBT must contain a valid "id" field (e.g. "minecraft:chest"). + +/ + Result!(void, WitString) setBlockEntityNbt(in BlockPos pos, in WitList!(ubyte) nbtData) @trusted nothrow { + align(size_t.sizeof) void[(3*size_t.sizeof)] _retArea = void; + __import_setBlockEntityNbt(this.__handle, cast(uint)(pos.x), cast(uint)(pos.y), cast(uint)(pos.z), cast(void*)(nbtData.ptr), nbtData.length, _retArea.ptr); + Result!(void, WitString) _result4 = void; + bool _isErr4 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isErr4) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + + _result4 = Result!(void, WitString).makeErr(_list3); + } else { + + _result4 = Result!(void, WitString).makeOk(); + } + auto _flush5 = _result4; + return _flush5; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.set-block-entity-nbt") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.set_block_entity_nbt") + static private extern(C) void __import_setBlockEntityNbt(uint, uint, uint, uint, void*, size_t, void*) nothrow; + + /++ + Returns the name of this world (e.g. "world", "world_nether", "arena_1"). + +/ + WitString getName() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getName(this.__handle, _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(char*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitString(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-name") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_name") + static private extern(C) void __import_getName(uint, void*) nothrow; + + /++ + Saves all chunk data, block entities, and entities for this world to disk. + +/ + Result!(void, WitString) save() @trusted nothrow { + align(size_t.sizeof) void[(3*size_t.sizeof)] _retArea = void; + __import_save(this.__handle, _retArea.ptr); + Result!(void, WitString) _result4 = void; + bool _isErr4 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isErr4) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + + _result4 = Result!(void, WitString).makeErr(_list3); + } else { + + _result4 = Result!(void, WitString).makeOk(); + } + auto _flush5 = _result4; + return _flush5; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.save") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.save") + static private extern(C) void __import_save(uint, void*) nothrow; + + /++ + Sets a custom chunk generator for this world using a registered generator ID. + +/ + void setChunkGenerator(uint generatorId) @trusted nothrow { + __import_setChunkGenerator(this.__handle, generatorId); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.set-chunk-generator") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.set_chunk_generator") + static private extern(C) void __import_setChunkGenerator(uint, uint) nothrow; + + /++ + Sets a namespaced custom data value on this world. + +/ + void setCustomData(in WitString namespace, in WitString key, in NbtTree value) @trusted nothrow { + wit.common.DeallocateBuffer deallocate; + auto _listSrc28 = value.tags; + auto _list28 = _listSrc28.length ? wit.common.malloc(_listSrc28.length * ((8+2*size_t.sizeof))) : null; + assert(!_listSrc28.length || _list28); + if (_listSrc28.length) deallocate ~= _list28; + foreach (_elem0_idx, ref _elem0; _listSrc28) { + auto _base0 = _list28 + _elem0_idx * ((8+2*size_t.sizeof)); + alias _Tag27 = wit.pumpkin.plugin.common.imports.NbtTag.Tag; + final switch (_elem0.tag) { + case _Tag27.byte_: { + const ref byte _payload2 = _elem0.getByte(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(0); + *cast(ubyte*)(_base0 + 8) = cast(ubyte)(cast(uint)(_payload2)); + break; + } + case _Tag27.short_: { + const ref short _payload4 = _elem0.getShort(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(1); + *cast(ushort*)(_base0 + 8) = cast(ushort)(cast(uint)(_payload4)); + break; + } + case _Tag27.int_: { + const ref int _payload6 = _elem0.getInt(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(2); + *cast(uint*)(_base0 + 8) = cast(uint)(cast(uint)(_payload6)); + break; + } + case _Tag27.long_: { + const ref long _payload8 = _elem0.getLong(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(3); + *cast(ulong*)(_base0 + 8) = cast(ulong)(cast(ulong)(_payload8)); + break; + } + case _Tag27.float_: { + const ref float _payload10 = _elem0.getFloat(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(4); + *cast(float*)(_base0 + 8) = cast(float)(_payload10); + break; + } + case _Tag27.double_: { + const ref double _payload12 = _elem0.getDouble(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(5); + *cast(double*)(_base0 + 8) = cast(double)(_payload12); + break; + } + case _Tag27.byteArray: { + const ref WitList!(byte) _payload14 = _elem0.getByteArray(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(6); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload14.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload14.ptr)); + break; + } + case _Tag27.stringTag: { + const ref WitString _payload16 = _elem0.getStringTag(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(7); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload16.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload16.ptr)); + break; + } + case _Tag27.listTag: { + const ref WitList!(uint) _payload18 = _elem0.getListTag(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(8); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload18.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload18.ptr)); + break; + } + case _Tag27.compound: { + const ref WitList!(wit.pumpkin.plugin.common.imports.NbtEntry) _payload20 = _elem0.getCompound(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(9); + auto _listSrc22 = _payload20; + auto _list22 = _listSrc22.length ? wit.common.malloc(_listSrc22.length * ((3*size_t.sizeof))) : null; + assert(!_listSrc22.length || _list22); + if (_listSrc22.length) deallocate ~= _list22; + foreach (_elem21_idx, ref _elem21; _listSrc22) { + auto _base21 = _list22 + _elem21_idx * ((3*size_t.sizeof)); + *cast(size_t*)(_base21 + size_t.sizeof) = cast(size_t)(_elem21.key.length); + *cast(void**)(_base21 + 0) = cast(void*)(cast(void*)(_elem21.key.ptr)); + *cast(uint*)(_base21 + (2*size_t.sizeof)) = cast(uint)(_elem21.value); + + } + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload20.length); + *cast(void**)(_base0 + 8) = cast(void*)(_list22); + break; + } + case _Tag27.intArray: { + const ref WitList!(int) _payload24 = _elem0.getIntArray(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(10); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload24.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload24.ptr)); + break; + } + case _Tag27.longArray: { + const ref WitList!(long) _payload26 = _elem0.getLongArray(); + *cast(ubyte*)(_base0 + 0) = cast(ubyte)(11); + *cast(size_t*)(_base0 + (8+1*size_t.sizeof)) = cast(size_t)(_payload26.length); + *cast(void**)(_base0 + 8) = cast(void*)(cast(void*)(_payload26.ptr)); + break; + } + } + + } + __import_setCustomData(this.__handle, cast(void*)(namespace.ptr), namespace.length, cast(void*)(key.ptr), key.length, value.root, _list28, value.tags.length); + deallocate.purge(); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.set-custom-data") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.set_custom_data") + static private extern(C) void __import_setCustomData(uint, void*, size_t, void*, size_t, uint, void*, size_t) nothrow; + + /++ + Returns a namespaced custom data value from this world, if set. + +/ + Option!(NbtTree) getCustomData(in WitString namespace, in WitString key) @trusted nothrow { + align(size_t.sizeof) void[(4*size_t.sizeof)] _retArea = void; + __import_getCustomData(this.__handle, cast(void*)(namespace.ptr), namespace.length, cast(void*)(key.ptr), key.length, _retArea.ptr); + Option!(NbtTree) _option47 = void; + bool _isSome47 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome47) { + auto _listSrcPtr44 = *(cast(void**)(_retArea.ptr + (2*size_t.sizeof))); + auto _listLen44 = *(cast(size_t*)(_retArea.ptr + (3*size_t.sizeof))); + auto _list44 = _listLen44 ? wit.common.mallocSlice!(wit.pumpkin.plugin.common.imports.NbtTag)(_listLen44) : []; + assert(!_listLen44 || _list44.ptr); + foreach (_elem2_idx, ref _elem2; _list44) { + const auto _base2 = _listSrcPtr44 + _elem2_idx * (8+2*size_t.sizeof); + wit.pumpkin.plugin.common.imports.NbtTag _variant31 = void; + auto _tag31 = cast(uint)(*(cast(ubyte*)(_base2 + 0))); + alias _Tag31 = wit.pumpkin.plugin.common.imports.NbtTag.Tag; + final switch (cast(wit.pumpkin.plugin.common.imports.NbtTag.Tag)_tag31) { + case _Tag31.byte_: { + auto _payload32 = cast(byte)(cast(uint)(*(cast(byte*)(_base2 + 8)))); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.byte_(_payload32); + break; + } + case _Tag31.short_: { + auto _payload33 = cast(short)(cast(uint)(*(cast(short*)(_base2 + 8)))); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.short_(_payload33); + break; + } + case _Tag31.int_: { + auto _payload34 = cast(int)(*(cast(uint*)(_base2 + 8))); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.int_(_payload34); + break; + } + case _Tag31.long_: { + auto _payload35 = cast(long)(*(cast(ulong*)(_base2 + 8))); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.long_(_payload35); + break; + } + case _Tag31.float_: { + auto _payload36 = *(cast(float*)(_base2 + 8)); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.float_(_payload36); + break; + } + case _Tag31.double_: { + auto _payload37 = *(cast(double*)(_base2 + 8)); + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.double_(_payload37); + break; + } + case _Tag31.byteArray: { + auto _len10 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr10 = _len10 ? cast(byte*)(*(cast(void**)(_base2 + 8))) : null; + auto _list11 = WitList!(byte)(_ptr10[0.._len10]); + auto _payload38 = _list11; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.byteArray(_payload38); + break; + } + case _Tag31.stringTag: { + auto _len13 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr13 = _len13 ? cast(char*)(*(cast(void**)(_base2 + 8))) : null; + auto _list14 = WitString(_ptr13[0.._len13]); + auto _payload39 = _list14; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.stringTag(_payload39); + break; + } + case _Tag31.listTag: { + auto _len16 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr16 = _len16 ? cast(uint*)(*(cast(void**)(_base2 + 8))) : null; + auto _list17 = WitList!(uint)(_ptr16[0.._len16]); + auto _payload40 = _list17; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.listTag(_payload40); + break; + } + case _Tag31.compound: { + auto _listSrcPtr23 = *(cast(void**)(_base2 + 8)); + auto _listLen23 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _list23 = _listLen23 ? wit.common.mallocSlice!(wit.pumpkin.plugin.common.imports.NbtEntry)(_listLen23) : []; + assert(!_listLen23 || _list23.ptr); + foreach (_elem19_idx, ref _elem19; _list23) { + const auto _base19 = _listSrcPtr23 + _elem19_idx * (3*size_t.sizeof); + auto _len20 = *(cast(size_t*)(_base19 + size_t.sizeof)); + auto _ptr20 = _len20 ? cast(char*)(*(cast(void**)(_base19 + 0))) : null; + auto _list21 = WitString(_ptr20[0.._len20]); + wit.pumpkin.plugin.common.imports.NbtEntry _record22 = { + key: _list21, + value: *(cast(uint*)(_base19 + (2*size_t.sizeof))), + }; + _elem19 = _record22; + } + if (_listLen23) wit.common.free(_listSrcPtr23); + auto _witList24 = WitList!(wit.pumpkin.plugin.common.imports.NbtEntry)(_list23); + auto _payload41 = _witList24; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.compound(_payload41); + break; + } + case _Tag31.intArray: { + auto _len26 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr26 = _len26 ? cast(int*)(*(cast(void**)(_base2 + 8))) : null; + auto _list27 = WitList!(int)(_ptr26[0.._len26]); + auto _payload42 = _list27; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.intArray(_payload42); + break; + } + case _Tag31.longArray: { + auto _len29 = *(cast(size_t*)(_base2 + (8+1*size_t.sizeof))); + auto _ptr29 = _len29 ? cast(long*)(*(cast(void**)(_base2 + 8))) : null; + auto _list30 = WitList!(long)(_ptr29[0.._len29]); + auto _payload43 = _list30; + _variant31 = wit.pumpkin.plugin.common.imports.NbtTag.longArray(_payload43); + break; + } + } + _elem2 = _variant31; + } + if (_listLen44) wit.common.free(_listSrcPtr44); + auto _witList45 = WitList!(wit.pumpkin.plugin.common.imports.NbtTag)(_list44); + wit.pumpkin.plugin.common.imports.NbtTree _record46 = { + root: *(cast(uint*)(_retArea.ptr + size_t.sizeof)), + tags: _witList45, + }; + + _option47 = Option!(NbtTree).makeSome(_record46); + } else { + _option47 = Option!(NbtTree).makeNone; + } + auto _flush48 = _option47; + return _flush48; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-custom-data") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_custom_data") + static private extern(C) void __import_getCustomData(uint, void*, size_t, void*, size_t, void*) nothrow; + + /++ + Removes a namespaced custom data value from this world. + +/ + void removeCustomData(in WitString namespace, in WitString key) @trusted nothrow { + __import_removeCustomData(this.__handle, cast(void*)(namespace.ptr), namespace.length, cast(void*)(key.ptr), key.length); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.remove-custom-data") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.remove_custom_data") + static private extern(C) void __import_removeCustomData(uint, void*, size_t, void*, size_t) nothrow; + + /++ + Returns whether this world has a namespaced custom data value. + +/ + bool hasCustomData(in WitString namespace, in WitString key) @trusted nothrow { + auto _ret = __import_hasCustomData(this.__handle, cast(void*)(namespace.ptr), namespace.length, cast(void*)(key.ptr), key.length); + return (_ret) != 0; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.has-custom-data") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.has_custom_data") + static private extern(C) uint __import_hasCustomData(uint, void*, size_t, void*, size_t) nothrow; + + /++ + Gets the value of a game rule in this world. + +/ + GameRuleValue getGameRule(GameRule rule) @trusted nothrow { + align(4) void[8] _retArea = void; + __import_getGameRule(this.__handle, cast(uint)(rule), _retArea.ptr); + wit.pumpkin.plugin.game_rules.imports.GameRuleValue _variant2 = void; + auto _tag2 = cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0))); + alias _Tag2 = wit.pumpkin.plugin.game_rules.imports.GameRuleValue.Tag; + final switch (cast(wit.pumpkin.plugin.game_rules.imports.GameRuleValue.Tag)_tag2) { + case _Tag2.int_: { + auto _payload3 = cast(int)(*(cast(uint*)(_retArea.ptr + 4))); + _variant2 = wit.pumpkin.plugin.game_rules.imports.GameRuleValue.int_(_payload3); + break; + } + case _Tag2.bool_: { + auto _payload4 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 4)))) != 0; + _variant2 = wit.pumpkin.plugin.game_rules.imports.GameRuleValue.bool_(_payload4); + break; + } + } + auto _flush5 = _variant2; + return _flush5; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.get-game-rule") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.get_game_rule") + static private extern(C) void __import_getGameRule(uint, uint, void*) nothrow; + + /++ + Sets the value of a game rule in this world. + +/ + void setGameRule(GameRule rule, in GameRuleValue value) @trusted nothrow { + uint _variantPart4 = void; + uint _variantPart5 = void; + alias _Tag6 = wit.pumpkin.plugin.game_rules.imports.GameRuleValue.Tag; + final switch (value.tag) { + case _Tag6.int_: { + const ref int _payload1 = value.getInt(); + _variantPart4 = 0; + _variantPart5 = cast(uint)(_payload1); + break; + } + case _Tag6.bool_: { + const ref bool _payload3 = value.getBool(); + _variantPart4 = 1; + _variantPart5 = cast(uint)(_payload3); + break; + } + } + __import_setGameRule(this.__handle, cast(uint)(rule), _variantPart4, _variantPart5); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]world.set-game-rule") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:world.set_game_rule") + static private extern(C) void __import_setGameRule(uint, uint, uint, uint) nothrow; + } +} + +/++ +Mutable chunk buffer representing a 16x16 column during custom world generation. ++/ +struct ChunkBuffer { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + + pragma(inline, true) void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + @wasmImport!("pumpkin:plugin/world@0.1.0", "[resource-drop]chunk-buffer") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:resource_drop:chunk_buffer") + static private extern(C) void __import_drop(uint) @nogc nothrow; + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) typeof(this) witClone() const @safe @nogc nothrow { return typeof(this)(__handle); } + // TODO: make RAII? disable copy for the own + + Borrow borrow() => Borrow(__handle); + alias borrow this; + + struct Borrow { + package(wit) uint __handle = 0; + + pragma(inline, true) + package(wit) this(uint handle) @safe @nogc nothrow { + __handle = handle; + } + + pragma(inline, true) void witFree() @safe @nogc nothrow {} + pragma(inline, true) + void witDrop() @trusted @nogc nothrow { + if (!__handle) return; __import_drop(__handle); __handle = 0; + } + pragma(inline, true) Borrow witClone() const @safe @nogc nothrow { return Borrow(__handle); } + + /++ + Returns the chunk X coordinate. + +/ + int getX() @trusted nothrow { + auto _ret = __import_getX(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk-buffer.get-x") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk_buffer.get_x") + static private extern(C) uint __import_getX(uint) nothrow; + + /++ + Returns the chunk Z coordinate. + +/ + int getZ() @trusted nothrow { + auto _ret = __import_getZ(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk-buffer.get-z") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk_buffer.get_z") + static private extern(C) uint __import_getZ(uint) nothrow; + + /++ + Returns the minimum Y coordinate for this world. + +/ + int getMinY() @trusted nothrow { + auto _ret = __import_getMinY(this.__handle); + return cast(int)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk-buffer.get-min-y") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk_buffer.get_min_y") + static private extern(C) uint __import_getMinY(uint) nothrow; + + /++ + Returns the height of the chunk in blocks. + +/ + uint getHeight() @trusted nothrow { + auto _ret = __import_getHeight(this.__handle); + return _ret; + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk-buffer.get-height") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk_buffer.get_height") + static private extern(C) uint __import_getHeight(uint) nothrow; + + /++ + Sets the block state ID at local coordinates (0..16, y, 0..16). + +/ + void setBlockStateId(ubyte x, int y, ubyte z, ushort stateId) @trusted nothrow { + __import_setBlockStateId(this.__handle, cast(uint)(x), cast(uint)(y), cast(uint)(z), cast(uint)(stateId)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk-buffer.set-block-state-id") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk_buffer.set_block_state_id") + static private extern(C) void __import_setBlockStateId(uint, uint, uint, uint, uint) nothrow; + + /++ + Gets the block state ID at local coordinates (0..16, y, 0..16). + +/ + ushort getBlockStateId(ubyte x, int y, ubyte z) @trusted nothrow { + auto _ret = __import_getBlockStateId(this.__handle, cast(uint)(x), cast(uint)(y), cast(uint)(z)); + return cast(ushort)(_ret); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk-buffer.get-block-state-id") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk_buffer.get_block_state_id") + static private extern(C) uint __import_getBlockStateId(uint, uint, uint, uint) nothrow; + + /++ + Fills an entire horizontal 16x16 layer at the given Y level with a block state ID. + +/ + void fillLayer(int y, ushort stateId) @trusted nothrow { + __import_fillLayer(this.__handle, cast(uint)(y), cast(uint)(stateId)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk-buffer.fill-layer") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk_buffer.fill_layer") + static private extern(C) void __import_fillLayer(uint, uint, uint) nothrow; + + /++ + Fills a vertical column from min-y to max-y at local (x, z) with a block state ID. + +/ + void fillRange(ubyte x, int minY, int maxY, ubyte z, ushort stateId) @trusted nothrow { + __import_fillRange(this.__handle, cast(uint)(x), cast(uint)(minY), cast(uint)(maxY), cast(uint)(z), cast(uint)(stateId)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk-buffer.fill-range") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk_buffer.fill_range") + static private extern(C) void __import_fillRange(uint, uint, uint, uint, uint, uint) nothrow; + + /++ + Fills a 3D cuboid with a block state ID. + +/ + void fillCuboid(ubyte minX, int minY, ubyte minZ, ubyte maxX, int maxY, ubyte maxZ, ushort stateId) @trusted nothrow { + __import_fillCuboid(this.__handle, cast(uint)(minX), cast(uint)(minY), cast(uint)(minZ), cast(uint)(maxX), cast(uint)(maxY), cast(uint)(maxZ), cast(uint)(stateId)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk-buffer.fill-cuboid") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk_buffer.fill_cuboid") + static private extern(C) void __import_fillCuboid(uint, uint, uint, uint, uint, uint, uint, uint) nothrow; + + /++ + Sets the biome at local coordinates (0..16, y, 0..16). + +/ + void setBiome(ubyte x, int y, ubyte z, Biome biome) @trusted nothrow { + __import_setBiome(this.__handle, cast(uint)(x), cast(uint)(y), cast(uint)(z), cast(uint)(biome)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk-buffer.set-biome") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk_buffer.set_biome") + static private extern(C) void __import_setBiome(uint, uint, uint, uint, uint) nothrow; + + /++ + Fills the entire chunk with the given biome. + +/ + void fillBiome(Biome biome) @trusted nothrow { + __import_fillBiome(this.__handle, cast(uint)(biome)); + } + /// ditto + @wasmImport!("pumpkin:plugin/world@0.1.0", "[method]chunk-buffer.fill-biome") + pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__:method:chunk_buffer.fill_biome") + static private extern(C) void __import_fillBiome(uint, uint) nothrow; + } +} + +/++ +Resolves a block name and optional properties to a block state ID. +Returns none if the block name is unknown. ++/ +Option!(ushort) resolveBlockState(in WitString name, in WitList!(Tuple!(WitString, WitString)) properties) @trusted nothrow { + align(2) void[4] _retArea = void; + wit.common.DeallocateBuffer deallocate; + auto _listSrc1 = properties; + auto _list1 = _listSrc1.length ? wit.common.malloc(_listSrc1.length * ((4*size_t.sizeof))) : null; + assert(!_listSrc1.length || _list1); + if (_listSrc1.length) deallocate ~= _list1; + foreach (_elem0_idx, ref _elem0; _listSrc1) { + auto _base0 = _list1 + _elem0_idx * ((4*size_t.sizeof)); + *cast(size_t*)(_base0 + size_t.sizeof) = cast(size_t)(_elem0[0].length); + *cast(void**)(_base0 + 0) = cast(void*)(cast(void*)(_elem0[0].ptr)); + *cast(size_t*)(_base0 + (3*size_t.sizeof)) = cast(size_t)(_elem0[1].length); + *cast(void**)(_base0 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem0[1].ptr)); + + } + __import_resolveBlockState(cast(void*)(name.ptr), name.length, _list1, properties.length, _retArea.ptr); + deallocate.purge(); + Option!(ushort) _option4 = void; + bool _isSome4 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome4) { + + _option4 = Option!(ushort).makeSome(cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + 2))))); + } else { + _option4 = Option!(ushort).makeNone; + } + auto _flush5 = _option4; + return _flush5; +} +/// ditto +@wasmImport!("pumpkin:plugin/world@0.1.0", "resolve-block-state") +pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__resolve_block_state") +private extern(C) void __import_resolveBlockState(void*, size_t, void*, size_t, void*) nothrow; + +/++ +Resolves a block state ID back to its block name and properties. +Returns none if the state ID is unknown. ++/ +Option!(BlockStateInfo) blockStateToInfo(ushort stateId) @trusted nothrow { + align(size_t.sizeof) void[(5*size_t.sizeof)] _retArea = void; + __import_blockStateToInfo(cast(uint)(stateId), _retArea.ptr); + Option!(BlockStateInfo) _option13 = void; + bool _isSome13 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome13) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + auto _listSrcPtr10 = *(cast(void**)(_retArea.ptr + (3*size_t.sizeof))); + auto _listLen10 = *(cast(size_t*)(_retArea.ptr + (4*size_t.sizeof))); + auto _list10 = _listLen10 ? wit.common.mallocSlice!(Tuple!(WitString, WitString))(_listLen10) : []; + assert(!_listLen10 || _list10.ptr); + foreach (_elem4_idx, ref _elem4; _list10) { + const auto _base4 = _listSrcPtr10 + _elem4_idx * (4*size_t.sizeof); + auto _len5 = *(cast(size_t*)(_base4 + size_t.sizeof)); + auto _ptr5 = _len5 ? cast(char*)(*(cast(void**)(_base4 + 0))) : null; + auto _list6 = WitString(_ptr5[0.._len5]); + auto _len7 = *(cast(size_t*)(_base4 + (3*size_t.sizeof))); + auto _ptr7 = _len7 ? cast(char*)(*(cast(void**)(_base4 + (2*size_t.sizeof)))) : null; + auto _list8 = WitString(_ptr7[0.._len7]); + auto _tuple9 = Tuple!(WitString, WitString)( + _list6, + _list8, + ); + _elem4 = _tuple9; + } + if (_listLen10) wit.common.free(_listSrcPtr10); + auto _witList11 = WitList!(Tuple!(WitString, WitString))(_list10); + BlockStateInfo _record12 = { + name: _list3, + properties: _witList11, + }; + + _option13 = Option!(BlockStateInfo).makeSome(_record12); + } else { + _option13 = Option!(BlockStateInfo).makeNone; + } + auto _flush14 = _option13; + return _flush14; +} +/// ditto +@wasmImport!("pumpkin:plugin/world@0.1.0", "block-state-to-info") +pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__block_state_to_info") +private extern(C) void __import_blockStateToInfo(uint, void*) nothrow; + +/++ +Gets a block type by its numerical block ID. ++/ +Option!(Block) getBlockById(ushort id) @trusted nothrow { + align(size_t.sizeof) void[(32+7*size_t.sizeof)] _retArea = void; + __import_getBlockById(cast(uint)(id), _retArea.ptr); + Option!(Block) _option11 = void; + bool _isSome11 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome11) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (3*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + (2*size_t.sizeof)))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + auto _len4 = *(cast(size_t*)(_retArea.ptr + (24+6*size_t.sizeof))); + auto _ptr4 = _len4 ? cast(ushort*)(*(cast(void**)(_retArea.ptr + (24+5*size_t.sizeof)))) : null; + auto _list5 = WitList!(ushort)(_ptr4[0.._len4]); + Option!(Flammable) _option9 = void; + bool _isSome9 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (27+7*size_t.sizeof))))) != 0; + if (_isSome9) { + Flammable _record8 = { + spreadChance: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (28+7*size_t.sizeof))))), + burnChance: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (29+7*size_t.sizeof))))), + }; + + _option9 = Option!(Flammable).makeSome(_record8); + } else { + _option9 = Option!(Flammable).makeNone; + } + Block _record10 = { + id: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + size_t.sizeof)))), + name: _list3, + hardness: *(cast(float*)(_retArea.ptr + (4*size_t.sizeof))), + blastResistance: *(cast(float*)(_retArea.ptr + (4+4*size_t.sizeof))), + mapColor: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (8+4*size_t.sizeof))))), + slipperiness: *(cast(float*)(_retArea.ptr + (12+4*size_t.sizeof))), + velocityMultiplier: *(cast(float*)(_retArea.ptr + (16+4*size_t.sizeof))), + jumpVelocityMultiplier: *(cast(float*)(_retArea.ptr + (20+4*size_t.sizeof))), + itemId: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + (24+4*size_t.sizeof))))), + defaultStateId: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + (26+4*size_t.sizeof))))), + stateIds: _list5, + isSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (24+7*size_t.sizeof))))) != 0, + isAir: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (25+7*size_t.sizeof))))) != 0, + isFlammable: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (26+7*size_t.sizeof))))) != 0, + flammable: _option9, + }; + + _option11 = Option!(Block).makeSome(_record10); + } else { + _option11 = Option!(Block).makeNone; + } + auto _flush12 = _option11; + return _flush12; +} +/// ditto +@wasmImport!("pumpkin:plugin/world@0.1.0", "get-block-by-id") +pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__get_block_by_id") +private extern(C) void __import_getBlockById(uint, void*) nothrow; + +/++ +Gets a block type by its namespaced name (e.g., "minecraft:stone" or "stone"). ++/ +Option!(Block) getBlockByName(in WitString name) @trusted nothrow { + align(size_t.sizeof) void[(32+7*size_t.sizeof)] _retArea = void; + __import_getBlockByName(cast(void*)(name.ptr), name.length, _retArea.ptr); + Option!(Block) _option11 = void; + bool _isSome11 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome11) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (3*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + (2*size_t.sizeof)))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + auto _len4 = *(cast(size_t*)(_retArea.ptr + (24+6*size_t.sizeof))); + auto _ptr4 = _len4 ? cast(ushort*)(*(cast(void**)(_retArea.ptr + (24+5*size_t.sizeof)))) : null; + auto _list5 = WitList!(ushort)(_ptr4[0.._len4]); + Option!(Flammable) _option9 = void; + bool _isSome9 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (27+7*size_t.sizeof))))) != 0; + if (_isSome9) { + Flammable _record8 = { + spreadChance: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (28+7*size_t.sizeof))))), + burnChance: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (29+7*size_t.sizeof))))), + }; + + _option9 = Option!(Flammable).makeSome(_record8); + } else { + _option9 = Option!(Flammable).makeNone; + } + Block _record10 = { + id: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + size_t.sizeof)))), + name: _list3, + hardness: *(cast(float*)(_retArea.ptr + (4*size_t.sizeof))), + blastResistance: *(cast(float*)(_retArea.ptr + (4+4*size_t.sizeof))), + mapColor: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (8+4*size_t.sizeof))))), + slipperiness: *(cast(float*)(_retArea.ptr + (12+4*size_t.sizeof))), + velocityMultiplier: *(cast(float*)(_retArea.ptr + (16+4*size_t.sizeof))), + jumpVelocityMultiplier: *(cast(float*)(_retArea.ptr + (20+4*size_t.sizeof))), + itemId: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + (24+4*size_t.sizeof))))), + defaultStateId: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + (26+4*size_t.sizeof))))), + stateIds: _list5, + isSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (24+7*size_t.sizeof))))) != 0, + isAir: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (25+7*size_t.sizeof))))) != 0, + isFlammable: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (26+7*size_t.sizeof))))) != 0, + flammable: _option9, + }; + + _option11 = Option!(Block).makeSome(_record10); + } else { + _option11 = Option!(Block).makeNone; + } + auto _flush12 = _option11; + return _flush12; +} +/// ditto +@wasmImport!("pumpkin:plugin/world@0.1.0", "get-block-by-name") +pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__get_block_by_name") +private extern(C) void __import_getBlockByName(void*, size_t, void*) nothrow; + +/++ +Gets all registered blocks. ++/ +WitList!(Block) getAllBlocks() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getAllBlocks(_retArea.ptr); + auto _listSrcPtr10 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen10 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list10 = _listLen10 ? wit.common.mallocSlice!(Block)(_listLen10) : []; + assert(!_listLen10 || _list10.ptr); + foreach (_elem0_idx, ref _elem0; _list10) { + const auto _base0 = _listSrcPtr10 + _elem0_idx * (32+6*size_t.sizeof); + auto _len1 = *(cast(size_t*)(_base0 + (2*size_t.sizeof))); + auto _ptr1 = _len1 ? cast(char*)(*(cast(void**)(_base0 + size_t.sizeof))) : null; + auto _list2 = WitString(_ptr1[0.._len1]); + auto _len3 = *(cast(size_t*)(_base0 + (24+5*size_t.sizeof))); + auto _ptr3 = _len3 ? cast(ushort*)(*(cast(void**)(_base0 + (24+4*size_t.sizeof)))) : null; + auto _list4 = WitList!(ushort)(_ptr3[0.._len3]); + Option!(Flammable) _option8 = void; + bool _isSome8 = (cast(uint)(*(cast(ubyte*)(_base0 + (27+6*size_t.sizeof))))) != 0; + if (_isSome8) { + Flammable _record7 = { + spreadChance: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base0 + (28+6*size_t.sizeof))))), + burnChance: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base0 + (29+6*size_t.sizeof))))), + }; + + _option8 = Option!(Flammable).makeSome(_record7); + } else { + _option8 = Option!(Flammable).makeNone; + } + Block _record9 = { + id: cast(ushort)(cast(uint)(*(cast(ushort*)(_base0 + 0)))), + name: _list2, + hardness: *(cast(float*)(_base0 + (3*size_t.sizeof))), + blastResistance: *(cast(float*)(_base0 + (4+3*size_t.sizeof))), + mapColor: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base0 + (8+3*size_t.sizeof))))), + slipperiness: *(cast(float*)(_base0 + (12+3*size_t.sizeof))), + velocityMultiplier: *(cast(float*)(_base0 + (16+3*size_t.sizeof))), + jumpVelocityMultiplier: *(cast(float*)(_base0 + (20+3*size_t.sizeof))), + itemId: cast(ushort)(cast(uint)(*(cast(ushort*)(_base0 + (24+3*size_t.sizeof))))), + defaultStateId: cast(ushort)(cast(uint)(*(cast(ushort*)(_base0 + (26+3*size_t.sizeof))))), + stateIds: _list4, + isSolid: (cast(uint)(*(cast(ubyte*)(_base0 + (24+6*size_t.sizeof))))) != 0, + isAir: (cast(uint)(*(cast(ubyte*)(_base0 + (25+6*size_t.sizeof))))) != 0, + isFlammable: (cast(uint)(*(cast(ubyte*)(_base0 + (26+6*size_t.sizeof))))) != 0, + flammable: _option8, + }; + _elem0 = _record9; + } + if (_listLen10) wit.common.free(_listSrcPtr10); + auto _witList11 = WitList!(Block)(_list10); + auto _flush12 = _witList11; + return _flush12; +} +/// ditto +@wasmImport!("pumpkin:plugin/world@0.1.0", "get-all-blocks") +pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__get_all_blocks") +private extern(C) void __import_getAllBlocks(void*) nothrow; + +/++ +Gets the names of all registered blocks. ++/ +WitList!(WitString) getAllBlockNames() @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getAllBlockNames(_retArea.ptr); + auto _listSrcPtr3 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen3 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list3 = _listLen3 ? wit.common.mallocSlice!(WitString)(_listLen3) : []; + assert(!_listLen3 || _list3.ptr); + foreach (_elem0_idx, ref _elem0; _list3) { + const auto _base0 = _listSrcPtr3 + _elem0_idx * (2*size_t.sizeof); + auto _len1 = *(cast(size_t*)(_base0 + size_t.sizeof)); + auto _ptr1 = _len1 ? cast(char*)(*(cast(void**)(_base0 + 0))) : null; + auto _list2 = WitString(_ptr1[0.._len1]); + _elem0 = _list2; + } + if (_listLen3) wit.common.free(_listSrcPtr3); + auto _witList4 = WitList!(WitString)(_list3); + auto _flush5 = _witList4; + return _flush5; +} +/// ditto +@wasmImport!("pumpkin:plugin/world@0.1.0", "get-all-block-names") +pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__get_all_block_names") +private extern(C) void __import_getAllBlockNames(void*) nothrow; + +/++ +Gets the total number of registered block types. ++/ +uint getBlockCount() @trusted nothrow { + auto _ret = __import_getBlockCount(); + return _ret; +} +/// ditto +@wasmImport!("pumpkin:plugin/world@0.1.0", "get-block-count") +pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__get_block_count") +private extern(C) uint __import_getBlockCount() nothrow; + +/++ +Gets the total number of registered block states. ++/ +uint getBlockStateCount() @trusted nothrow { + auto _ret = __import_getBlockStateCount(); + return _ret; +} +/// ditto +@wasmImport!("pumpkin:plugin/world@0.1.0", "get-block-state-count") +pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__get_block_state_count") +private extern(C) uint __import_getBlockStateCount() nothrow; + +/++ +Gets all valid block states for a block type. ++/ +WitList!(BlockState) getStatesForBlock(in Block block) @trusted nothrow { + align(size_t.sizeof) void[(32+6*size_t.sizeof)] _retArea = void; + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(cast(uint)(block.id)); + *cast(size_t*)(_retArea.ptr + (2*size_t.sizeof)) = cast(size_t)(block.name.length); + *cast(void**)(_retArea.ptr + size_t.sizeof) = cast(void*)(cast(void*)(block.name.ptr)); + *cast(float*)(_retArea.ptr + (3*size_t.sizeof)) = cast(float)(block.hardness); + *cast(float*)(_retArea.ptr + (4+3*size_t.sizeof)) = cast(float)(block.blastResistance); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(block.mapColor)); + *cast(float*)(_retArea.ptr + (12+3*size_t.sizeof)) = cast(float)(block.slipperiness); + *cast(float*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(float)(block.velocityMultiplier); + *cast(float*)(_retArea.ptr + (20+3*size_t.sizeof)) = cast(float)(block.jumpVelocityMultiplier); + *cast(ushort*)(_retArea.ptr + (24+3*size_t.sizeof)) = cast(ushort)(cast(uint)(block.itemId)); + *cast(ushort*)(_retArea.ptr + (26+3*size_t.sizeof)) = cast(ushort)(cast(uint)(block.defaultStateId)); + *cast(size_t*)(_retArea.ptr + (24+5*size_t.sizeof)) = cast(size_t)(block.stateIds.length); + *cast(void**)(_retArea.ptr + (24+4*size_t.sizeof)) = cast(void*)(cast(void*)(block.stateIds.ptr)); + *cast(ubyte*)(_retArea.ptr + (24+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(block.isSolid)); + *cast(ubyte*)(_retArea.ptr + (25+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(block.isAir)); + *cast(ubyte*)(_retArea.ptr + (26+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(block.isFlammable)); + if (block.flammable.isSome) { + ref _payload3 = block.flammable.unwrap(); + *cast(ubyte*)(_retArea.ptr + (27+6*size_t.sizeof)) = cast(ubyte)(1); + *cast(ubyte*)(_retArea.ptr + (28+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload3.spreadChance)); + *cast(ubyte*)(_retArea.ptr + (29+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload3.burnChance)); + } else { + *cast(ubyte*)(_retArea.ptr + (27+6*size_t.sizeof)) = cast(ubyte)(0); + } + __import_getStatesForBlock(_retArea.ptr, _retArea.ptr); + auto _listSrcPtr20 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen20 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list20 = _listLen20 ? wit.common.mallocSlice!(BlockState)(_listLen20) : []; + assert(!_listLen20 || _list20.ptr); + foreach (_elem4_idx, ref _elem4; _list20) { + const auto _base4 = _listSrcPtr20 + _elem4_idx * (32+10*size_t.sizeof); + auto _len5 = *(cast(size_t*)(_base4 + (2*size_t.sizeof))); + auto _ptr5 = _len5 ? cast(char*)(*(cast(void**)(_base4 + size_t.sizeof))) : null; + auto _list6 = WitString(_ptr5[0.._len5]); + auto _len7 = *(cast(size_t*)(_base4 + (24+4*size_t.sizeof))); + auto _ptr7 = _len7 ? cast(BoundingBox*)(*(cast(void**)(_base4 + (24+3*size_t.sizeof)))) : null; + auto _list8 = WitList!(BoundingBox)(_ptr7[0.._len7]); + auto _len9 = *(cast(size_t*)(_base4 + (24+6*size_t.sizeof))); + auto _ptr9 = _len9 ? cast(BoundingBox*)(*(cast(void**)(_base4 + (24+5*size_t.sizeof)))) : null; + auto _list10 = WitList!(BoundingBox)(_ptr9[0.._len9]); + auto _listSrcPtr17 = *(cast(void**)(_base4 + (32+8*size_t.sizeof))); + auto _listLen17 = *(cast(size_t*)(_base4 + (32+9*size_t.sizeof))); + auto _list17 = _listLen17 ? wit.common.mallocSlice!(Tuple!(WitString, WitString))(_listLen17) : []; + assert(!_listLen17 || _list17.ptr); + foreach (_elem11_idx, ref _elem11; _list17) { + const auto _base11 = _listSrcPtr17 + _elem11_idx * (4*size_t.sizeof); + auto _len12 = *(cast(size_t*)(_base11 + size_t.sizeof)); + auto _ptr12 = _len12 ? cast(char*)(*(cast(void**)(_base11 + 0))) : null; + auto _list13 = WitString(_ptr12[0.._len12]); + auto _len14 = *(cast(size_t*)(_base11 + (3*size_t.sizeof))); + auto _ptr14 = _len14 ? cast(char*)(*(cast(void**)(_base11 + (2*size_t.sizeof)))) : null; + auto _list15 = WitString(_ptr14[0.._len14]); + auto _tuple16 = Tuple!(WitString, WitString)( + _list13, + _list15, + ); + _elem11 = _tuple16; + } + if (_listLen17) wit.common.free(_listSrcPtr17); + auto _witList18 = WitList!(Tuple!(WitString, WitString))(_list17); + BlockState _record19 = { + id: cast(ushort)(cast(uint)(*(cast(ushort*)(_base4 + 0)))), + blockId: cast(ushort)(cast(uint)(*(cast(ushort*)(_base4 + 2)))), + blockName: _list6, + luminance: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base4 + (3*size_t.sizeof))))), + opacity: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base4 + (1+3*size_t.sizeof))))), + hardness: *(cast(float*)(_base4 + (4+3*size_t.sizeof))), + isAir: (cast(uint)(*(cast(ubyte*)(_base4 + (8+3*size_t.sizeof))))) != 0, + isLiquid: (cast(uint)(*(cast(ubyte*)(_base4 + (9+3*size_t.sizeof))))) != 0, + isSolid: (cast(uint)(*(cast(ubyte*)(_base4 + (10+3*size_t.sizeof))))) != 0, + isFullCube: (cast(uint)(*(cast(ubyte*)(_base4 + (11+3*size_t.sizeof))))) != 0, + pistonBehavior: cast(PistonBehavior)(cast(uint)(*(cast(ubyte*)(_base4 + (12+3*size_t.sizeof))))), + hasRandomTicks: (cast(uint)(*(cast(ubyte*)(_base4 + (13+3*size_t.sizeof))))) != 0, + burnable: (cast(uint)(*(cast(ubyte*)(_base4 + (14+3*size_t.sizeof))))) != 0, + toolRequired: (cast(uint)(*(cast(ubyte*)(_base4 + (15+3*size_t.sizeof))))) != 0, + sidedTransparency: (cast(uint)(*(cast(ubyte*)(_base4 + (16+3*size_t.sizeof))))) != 0, + replaceable: (cast(uint)(*(cast(ubyte*)(_base4 + (17+3*size_t.sizeof))))) != 0, + isSolidBlock: (cast(uint)(*(cast(ubyte*)(_base4 + (18+3*size_t.sizeof))))) != 0, + blockEntityType: cast(ushort)(cast(uint)(*(cast(ushort*)(_base4 + (20+3*size_t.sizeof))))), + instrument: cast(NoteblockInstrument)(cast(uint)(*(cast(ubyte*)(_base4 + (22+3*size_t.sizeof))))), + collisionShapes: _list8, + outlineShapes: _list10, + downSideSolid: (cast(uint)(*(cast(ubyte*)(_base4 + (24+7*size_t.sizeof))))) != 0, + upSideSolid: (cast(uint)(*(cast(ubyte*)(_base4 + (25+7*size_t.sizeof))))) != 0, + northSideSolid: (cast(uint)(*(cast(ubyte*)(_base4 + (26+7*size_t.sizeof))))) != 0, + southSideSolid: (cast(uint)(*(cast(ubyte*)(_base4 + (27+7*size_t.sizeof))))) != 0, + westSideSolid: (cast(uint)(*(cast(ubyte*)(_base4 + (28+7*size_t.sizeof))))) != 0, + eastSideSolid: (cast(uint)(*(cast(ubyte*)(_base4 + (29+7*size_t.sizeof))))) != 0, + downCenterSolid: (cast(uint)(*(cast(ubyte*)(_base4 + (30+7*size_t.sizeof))))) != 0, + upCenterSolid: (cast(uint)(*(cast(ubyte*)(_base4 + (31+7*size_t.sizeof))))) != 0, + mapColor: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base4 + (32+7*size_t.sizeof))))), + properties: _witList18, + }; + _elem4 = _record19; + } + if (_listLen20) wit.common.free(_listSrcPtr20); + auto _witList21 = WitList!(BlockState)(_list20); + auto _flush22 = _witList21; + return _flush22; +} +/// ditto +@wasmImport!("pumpkin:plugin/world@0.1.0", "get-states-for-block") +pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__get_states_for_block") +private extern(C) void __import_getStatesForBlock(void*, void*) nothrow; + +/++ +Gets all valid block states for a numerical block ID. ++/ +WitList!(BlockState) getStatesForBlockId(ushort blockId) @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getStatesForBlockId(cast(uint)(blockId), _retArea.ptr); + auto _listSrcPtr16 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen16 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list16 = _listLen16 ? wit.common.mallocSlice!(BlockState)(_listLen16) : []; + assert(!_listLen16 || _list16.ptr); + foreach (_elem0_idx, ref _elem0; _list16) { + const auto _base0 = _listSrcPtr16 + _elem0_idx * (32+10*size_t.sizeof); + auto _len1 = *(cast(size_t*)(_base0 + (2*size_t.sizeof))); + auto _ptr1 = _len1 ? cast(char*)(*(cast(void**)(_base0 + size_t.sizeof))) : null; + auto _list2 = WitString(_ptr1[0.._len1]); + auto _len3 = *(cast(size_t*)(_base0 + (24+4*size_t.sizeof))); + auto _ptr3 = _len3 ? cast(BoundingBox*)(*(cast(void**)(_base0 + (24+3*size_t.sizeof)))) : null; + auto _list4 = WitList!(BoundingBox)(_ptr3[0.._len3]); + auto _len5 = *(cast(size_t*)(_base0 + (24+6*size_t.sizeof))); + auto _ptr5 = _len5 ? cast(BoundingBox*)(*(cast(void**)(_base0 + (24+5*size_t.sizeof)))) : null; + auto _list6 = WitList!(BoundingBox)(_ptr5[0.._len5]); + auto _listSrcPtr13 = *(cast(void**)(_base0 + (32+8*size_t.sizeof))); + auto _listLen13 = *(cast(size_t*)(_base0 + (32+9*size_t.sizeof))); + auto _list13 = _listLen13 ? wit.common.mallocSlice!(Tuple!(WitString, WitString))(_listLen13) : []; + assert(!_listLen13 || _list13.ptr); + foreach (_elem7_idx, ref _elem7; _list13) { + const auto _base7 = _listSrcPtr13 + _elem7_idx * (4*size_t.sizeof); + auto _len8 = *(cast(size_t*)(_base7 + size_t.sizeof)); + auto _ptr8 = _len8 ? cast(char*)(*(cast(void**)(_base7 + 0))) : null; + auto _list9 = WitString(_ptr8[0.._len8]); + auto _len10 = *(cast(size_t*)(_base7 + (3*size_t.sizeof))); + auto _ptr10 = _len10 ? cast(char*)(*(cast(void**)(_base7 + (2*size_t.sizeof)))) : null; + auto _list11 = WitString(_ptr10[0.._len10]); + auto _tuple12 = Tuple!(WitString, WitString)( + _list9, + _list11, + ); + _elem7 = _tuple12; + } + if (_listLen13) wit.common.free(_listSrcPtr13); + auto _witList14 = WitList!(Tuple!(WitString, WitString))(_list13); + BlockState _record15 = { + id: cast(ushort)(cast(uint)(*(cast(ushort*)(_base0 + 0)))), + blockId: cast(ushort)(cast(uint)(*(cast(ushort*)(_base0 + 2)))), + blockName: _list2, + luminance: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base0 + (3*size_t.sizeof))))), + opacity: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base0 + (1+3*size_t.sizeof))))), + hardness: *(cast(float*)(_base0 + (4+3*size_t.sizeof))), + isAir: (cast(uint)(*(cast(ubyte*)(_base0 + (8+3*size_t.sizeof))))) != 0, + isLiquid: (cast(uint)(*(cast(ubyte*)(_base0 + (9+3*size_t.sizeof))))) != 0, + isSolid: (cast(uint)(*(cast(ubyte*)(_base0 + (10+3*size_t.sizeof))))) != 0, + isFullCube: (cast(uint)(*(cast(ubyte*)(_base0 + (11+3*size_t.sizeof))))) != 0, + pistonBehavior: cast(PistonBehavior)(cast(uint)(*(cast(ubyte*)(_base0 + (12+3*size_t.sizeof))))), + hasRandomTicks: (cast(uint)(*(cast(ubyte*)(_base0 + (13+3*size_t.sizeof))))) != 0, + burnable: (cast(uint)(*(cast(ubyte*)(_base0 + (14+3*size_t.sizeof))))) != 0, + toolRequired: (cast(uint)(*(cast(ubyte*)(_base0 + (15+3*size_t.sizeof))))) != 0, + sidedTransparency: (cast(uint)(*(cast(ubyte*)(_base0 + (16+3*size_t.sizeof))))) != 0, + replaceable: (cast(uint)(*(cast(ubyte*)(_base0 + (17+3*size_t.sizeof))))) != 0, + isSolidBlock: (cast(uint)(*(cast(ubyte*)(_base0 + (18+3*size_t.sizeof))))) != 0, + blockEntityType: cast(ushort)(cast(uint)(*(cast(ushort*)(_base0 + (20+3*size_t.sizeof))))), + instrument: cast(NoteblockInstrument)(cast(uint)(*(cast(ubyte*)(_base0 + (22+3*size_t.sizeof))))), + collisionShapes: _list4, + outlineShapes: _list6, + downSideSolid: (cast(uint)(*(cast(ubyte*)(_base0 + (24+7*size_t.sizeof))))) != 0, + upSideSolid: (cast(uint)(*(cast(ubyte*)(_base0 + (25+7*size_t.sizeof))))) != 0, + northSideSolid: (cast(uint)(*(cast(ubyte*)(_base0 + (26+7*size_t.sizeof))))) != 0, + southSideSolid: (cast(uint)(*(cast(ubyte*)(_base0 + (27+7*size_t.sizeof))))) != 0, + westSideSolid: (cast(uint)(*(cast(ubyte*)(_base0 + (28+7*size_t.sizeof))))) != 0, + eastSideSolid: (cast(uint)(*(cast(ubyte*)(_base0 + (29+7*size_t.sizeof))))) != 0, + downCenterSolid: (cast(uint)(*(cast(ubyte*)(_base0 + (30+7*size_t.sizeof))))) != 0, + upCenterSolid: (cast(uint)(*(cast(ubyte*)(_base0 + (31+7*size_t.sizeof))))) != 0, + mapColor: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_base0 + (32+7*size_t.sizeof))))), + properties: _witList14, + }; + _elem0 = _record15; + } + if (_listLen16) wit.common.free(_listSrcPtr16); + auto _witList17 = WitList!(BlockState)(_list16); + auto _flush18 = _witList17; + return _flush18; +} +/// ditto +@wasmImport!("pumpkin:plugin/world@0.1.0", "get-states-for-block-id") +pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__get_states_for_block_id") +private extern(C) void __import_getStatesForBlockId(uint, void*) nothrow; + +/++ +Gets all valid state IDs for a numerical block ID. ++/ +WitList!(ushort) getStateIdsForBlockId(ushort blockId) @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getStateIdsForBlockId(cast(uint)(blockId), _retArea.ptr); + auto _len0 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _ptr0 = _len0 ? cast(ushort*)(*(cast(void**)(_retArea.ptr + 0))) : null; + auto _list1 = WitList!(ushort)(_ptr0[0.._len0]); + auto _flush2 = _list1; + return _flush2; +} +/// ditto +@wasmImport!("pumpkin:plugin/world@0.1.0", "get-state-ids-for-block-id") +pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__get_state_ids_for_block_id") +private extern(C) void __import_getStateIdsForBlockId(uint, void*) nothrow; + +/++ +Gets property key-value pairs for a numerical block state ID. ++/ +WitList!(Tuple!(WitString, WitString)) getBlockProperties(ushort stateId) @trusted nothrow { + align(size_t.sizeof) void[(2*size_t.sizeof)] _retArea = void; + __import_getBlockProperties(cast(uint)(stateId), _retArea.ptr); + auto _listSrcPtr6 = *(cast(void**)(_retArea.ptr + 0)); + auto _listLen6 = *(cast(size_t*)(_retArea.ptr + size_t.sizeof)); + auto _list6 = _listLen6 ? wit.common.mallocSlice!(Tuple!(WitString, WitString))(_listLen6) : []; + assert(!_listLen6 || _list6.ptr); + foreach (_elem0_idx, ref _elem0; _list6) { + const auto _base0 = _listSrcPtr6 + _elem0_idx * (4*size_t.sizeof); + auto _len1 = *(cast(size_t*)(_base0 + size_t.sizeof)); + auto _ptr1 = _len1 ? cast(char*)(*(cast(void**)(_base0 + 0))) : null; + auto _list2 = WitString(_ptr1[0.._len1]); + auto _len3 = *(cast(size_t*)(_base0 + (3*size_t.sizeof))); + auto _ptr3 = _len3 ? cast(char*)(*(cast(void**)(_base0 + (2*size_t.sizeof)))) : null; + auto _list4 = WitString(_ptr3[0.._len3]); + auto _tuple5 = Tuple!(WitString, WitString)( + _list2, + _list4, + ); + _elem0 = _tuple5; + } + if (_listLen6) wit.common.free(_listSrcPtr6); + auto _witList7 = WitList!(Tuple!(WitString, WitString))(_list6); + auto _flush8 = _witList7; + return _flush8; +} +/// ditto +@wasmImport!("pumpkin:plugin/world@0.1.0", "get-block-properties") +pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__get_block_properties") +private extern(C) void __import_getBlockProperties(uint, void*) nothrow; + +/++ +Gets the block type associated with a block state ID. ++/ +Option!(Block) getBlockFromStateId(ushort stateId) @trusted nothrow { + align(size_t.sizeof) void[(32+7*size_t.sizeof)] _retArea = void; + __import_getBlockFromStateId(cast(uint)(stateId), _retArea.ptr); + Option!(Block) _option11 = void; + bool _isSome11 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome11) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (3*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + (2*size_t.sizeof)))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + auto _len4 = *(cast(size_t*)(_retArea.ptr + (24+6*size_t.sizeof))); + auto _ptr4 = _len4 ? cast(ushort*)(*(cast(void**)(_retArea.ptr + (24+5*size_t.sizeof)))) : null; + auto _list5 = WitList!(ushort)(_ptr4[0.._len4]); + Option!(Flammable) _option9 = void; + bool _isSome9 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (27+7*size_t.sizeof))))) != 0; + if (_isSome9) { + Flammable _record8 = { + spreadChance: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (28+7*size_t.sizeof))))), + burnChance: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (29+7*size_t.sizeof))))), + }; + + _option9 = Option!(Flammable).makeSome(_record8); + } else { + _option9 = Option!(Flammable).makeNone; + } + Block _record10 = { + id: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + size_t.sizeof)))), + name: _list3, + hardness: *(cast(float*)(_retArea.ptr + (4*size_t.sizeof))), + blastResistance: *(cast(float*)(_retArea.ptr + (4+4*size_t.sizeof))), + mapColor: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (8+4*size_t.sizeof))))), + slipperiness: *(cast(float*)(_retArea.ptr + (12+4*size_t.sizeof))), + velocityMultiplier: *(cast(float*)(_retArea.ptr + (16+4*size_t.sizeof))), + jumpVelocityMultiplier: *(cast(float*)(_retArea.ptr + (20+4*size_t.sizeof))), + itemId: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + (24+4*size_t.sizeof))))), + defaultStateId: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + (26+4*size_t.sizeof))))), + stateIds: _list5, + isSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (24+7*size_t.sizeof))))) != 0, + isAir: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (25+7*size_t.sizeof))))) != 0, + isFlammable: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (26+7*size_t.sizeof))))) != 0, + flammable: _option9, + }; + + _option11 = Option!(Block).makeSome(_record10); + } else { + _option11 = Option!(Block).makeNone; + } + auto _flush12 = _option11; + return _flush12; +} +/// ditto +@wasmImport!("pumpkin:plugin/world@0.1.0", "get-block-from-state-id") +pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__get_block_from_state_id") +private extern(C) void __import_getBlockFromStateId(uint, void*) nothrow; + +/++ +Gets the block type associated with a block state. ++/ +Block getBlockFromState(in BlockState state) @trusted nothrow { + align(size_t.sizeof) void[(32+10*size_t.sizeof)] _retArea = void; + wit.common.DeallocateBuffer deallocate; + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(cast(uint)(state.id)); + *cast(ushort*)(_retArea.ptr + 2) = cast(ushort)(cast(uint)(state.blockId)); + *cast(size_t*)(_retArea.ptr + (2*size_t.sizeof)) = cast(size_t)(state.blockName.length); + *cast(void**)(_retArea.ptr + size_t.sizeof) = cast(void*)(cast(void*)(state.blockName.ptr)); + *cast(ubyte*)(_retArea.ptr + (3*size_t.sizeof)) = cast(ubyte)(cast(uint)(state.luminance)); + *cast(ubyte*)(_retArea.ptr + (1+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(state.opacity)); + *cast(float*)(_retArea.ptr + (4+3*size_t.sizeof)) = cast(float)(state.hardness); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(state.isAir)); + *cast(ubyte*)(_retArea.ptr + (9+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(state.isLiquid)); + *cast(ubyte*)(_retArea.ptr + (10+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(state.isSolid)); + *cast(ubyte*)(_retArea.ptr + (11+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(state.isFullCube)); + *cast(ubyte*)(_retArea.ptr + (12+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(state.pistonBehavior)); + *cast(ubyte*)(_retArea.ptr + (13+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(state.hasRandomTicks)); + *cast(ubyte*)(_retArea.ptr + (14+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(state.burnable)); + *cast(ubyte*)(_retArea.ptr + (15+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(state.toolRequired)); + *cast(ubyte*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(state.sidedTransparency)); + *cast(ubyte*)(_retArea.ptr + (17+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(state.replaceable)); + *cast(ubyte*)(_retArea.ptr + (18+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(state.isSolidBlock)); + *cast(ushort*)(_retArea.ptr + (20+3*size_t.sizeof)) = cast(ushort)(cast(uint)(state.blockEntityType)); + *cast(ubyte*)(_retArea.ptr + (22+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(state.instrument)); + *cast(size_t*)(_retArea.ptr + (24+4*size_t.sizeof)) = cast(size_t)(state.collisionShapes.length); + *cast(void**)(_retArea.ptr + (24+3*size_t.sizeof)) = cast(void*)(cast(void*)(state.collisionShapes.ptr)); + *cast(size_t*)(_retArea.ptr + (24+6*size_t.sizeof)) = cast(size_t)(state.outlineShapes.length); + *cast(void**)(_retArea.ptr + (24+5*size_t.sizeof)) = cast(void*)(cast(void*)(state.outlineShapes.ptr)); + *cast(ubyte*)(_retArea.ptr + (24+7*size_t.sizeof)) = cast(ubyte)(cast(uint)(state.downSideSolid)); + *cast(ubyte*)(_retArea.ptr + (25+7*size_t.sizeof)) = cast(ubyte)(cast(uint)(state.upSideSolid)); + *cast(ubyte*)(_retArea.ptr + (26+7*size_t.sizeof)) = cast(ubyte)(cast(uint)(state.northSideSolid)); + *cast(ubyte*)(_retArea.ptr + (27+7*size_t.sizeof)) = cast(ubyte)(cast(uint)(state.southSideSolid)); + *cast(ubyte*)(_retArea.ptr + (28+7*size_t.sizeof)) = cast(ubyte)(cast(uint)(state.westSideSolid)); + *cast(ubyte*)(_retArea.ptr + (29+7*size_t.sizeof)) = cast(ubyte)(cast(uint)(state.eastSideSolid)); + *cast(ubyte*)(_retArea.ptr + (30+7*size_t.sizeof)) = cast(ubyte)(cast(uint)(state.downCenterSolid)); + *cast(ubyte*)(_retArea.ptr + (31+7*size_t.sizeof)) = cast(ubyte)(cast(uint)(state.upCenterSolid)); + *cast(ubyte*)(_retArea.ptr + (32+7*size_t.sizeof)) = cast(ubyte)(cast(uint)(state.mapColor)); + auto _listSrc1 = state.properties; + auto _list1 = _listSrc1.length ? wit.common.malloc(_listSrc1.length * ((4*size_t.sizeof))) : null; + assert(!_listSrc1.length || _list1); + if (_listSrc1.length) deallocate ~= _list1; + foreach (_elem0_idx, ref _elem0; _listSrc1) { + auto _base0 = _list1 + _elem0_idx * ((4*size_t.sizeof)); + *cast(size_t*)(_base0 + size_t.sizeof) = cast(size_t)(_elem0[0].length); + *cast(void**)(_base0 + 0) = cast(void*)(cast(void*)(_elem0[0].ptr)); + *cast(size_t*)(_base0 + (3*size_t.sizeof)) = cast(size_t)(_elem0[1].length); + *cast(void**)(_base0 + (2*size_t.sizeof)) = cast(void*)(cast(void*)(_elem0[1].ptr)); + + } + *cast(size_t*)(_retArea.ptr + (32+9*size_t.sizeof)) = cast(size_t)(state.properties.length); + *cast(void**)(_retArea.ptr + (32+8*size_t.sizeof)) = cast(void*)(_list1); + __import_getBlockFromState(_retArea.ptr, _retArea.ptr); + deallocate.purge(); + auto _len2 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + auto _len4 = *(cast(size_t*)(_retArea.ptr + (24+5*size_t.sizeof))); + auto _ptr4 = _len4 ? cast(ushort*)(*(cast(void**)(_retArea.ptr + (24+4*size_t.sizeof)))) : null; + auto _list5 = WitList!(ushort)(_ptr4[0.._len4]); + Option!(Flammable) _option9 = void; + bool _isSome9 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (27+6*size_t.sizeof))))) != 0; + if (_isSome9) { + Flammable _record8 = { + spreadChance: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (28+6*size_t.sizeof))))), + burnChance: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (29+6*size_t.sizeof))))), + }; + + _option9 = Option!(Flammable).makeSome(_record8); + } else { + _option9 = Option!(Flammable).makeNone; + } + Block _record10 = { + id: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + 0)))), + name: _list3, + hardness: *(cast(float*)(_retArea.ptr + (3*size_t.sizeof))), + blastResistance: *(cast(float*)(_retArea.ptr + (4+3*size_t.sizeof))), + mapColor: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof))))), + slipperiness: *(cast(float*)(_retArea.ptr + (12+3*size_t.sizeof))), + velocityMultiplier: *(cast(float*)(_retArea.ptr + (16+3*size_t.sizeof))), + jumpVelocityMultiplier: *(cast(float*)(_retArea.ptr + (20+3*size_t.sizeof))), + itemId: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + (24+3*size_t.sizeof))))), + defaultStateId: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + (26+3*size_t.sizeof))))), + stateIds: _list5, + isSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (24+6*size_t.sizeof))))) != 0, + isAir: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (25+6*size_t.sizeof))))) != 0, + isFlammable: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (26+6*size_t.sizeof))))) != 0, + flammable: _option9, + }; + auto _flush11 = _record10; + return _flush11; +} +/// ditto +@wasmImport!("pumpkin:plugin/world@0.1.0", "get-block-from-state") +pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__get_block_from_state") +private extern(C) void __import_getBlockFromState(void*, void*) nothrow; + +/++ +Gets the default block state for a block type. ++/ +BlockState getDefaultStateFromBlock(in Block block) @trusted nothrow { + align(size_t.sizeof) void[(32+10*size_t.sizeof)] _retArea = void; + *cast(ushort*)(_retArea.ptr + 0) = cast(ushort)(cast(uint)(block.id)); + *cast(size_t*)(_retArea.ptr + (2*size_t.sizeof)) = cast(size_t)(block.name.length); + *cast(void**)(_retArea.ptr + size_t.sizeof) = cast(void*)(cast(void*)(block.name.ptr)); + *cast(float*)(_retArea.ptr + (3*size_t.sizeof)) = cast(float)(block.hardness); + *cast(float*)(_retArea.ptr + (4+3*size_t.sizeof)) = cast(float)(block.blastResistance); + *cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof)) = cast(ubyte)(cast(uint)(block.mapColor)); + *cast(float*)(_retArea.ptr + (12+3*size_t.sizeof)) = cast(float)(block.slipperiness); + *cast(float*)(_retArea.ptr + (16+3*size_t.sizeof)) = cast(float)(block.velocityMultiplier); + *cast(float*)(_retArea.ptr + (20+3*size_t.sizeof)) = cast(float)(block.jumpVelocityMultiplier); + *cast(ushort*)(_retArea.ptr + (24+3*size_t.sizeof)) = cast(ushort)(cast(uint)(block.itemId)); + *cast(ushort*)(_retArea.ptr + (26+3*size_t.sizeof)) = cast(ushort)(cast(uint)(block.defaultStateId)); + *cast(size_t*)(_retArea.ptr + (24+5*size_t.sizeof)) = cast(size_t)(block.stateIds.length); + *cast(void**)(_retArea.ptr + (24+4*size_t.sizeof)) = cast(void*)(cast(void*)(block.stateIds.ptr)); + *cast(ubyte*)(_retArea.ptr + (24+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(block.isSolid)); + *cast(ubyte*)(_retArea.ptr + (25+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(block.isAir)); + *cast(ubyte*)(_retArea.ptr + (26+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(block.isFlammable)); + if (block.flammable.isSome) { + ref _payload3 = block.flammable.unwrap(); + *cast(ubyte*)(_retArea.ptr + (27+6*size_t.sizeof)) = cast(ubyte)(1); + *cast(ubyte*)(_retArea.ptr + (28+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload3.spreadChance)); + *cast(ubyte*)(_retArea.ptr + (29+6*size_t.sizeof)) = cast(ubyte)(cast(uint)(_payload3.burnChance)); + } else { + *cast(ubyte*)(_retArea.ptr + (27+6*size_t.sizeof)) = cast(ubyte)(0); + } + __import_getDefaultStateFromBlock(_retArea.ptr, _retArea.ptr); + auto _len4 = *(cast(size_t*)(_retArea.ptr + (2*size_t.sizeof))); + auto _ptr4 = _len4 ? cast(char*)(*(cast(void**)(_retArea.ptr + size_t.sizeof))) : null; + auto _list5 = WitString(_ptr4[0.._len4]); + auto _len6 = *(cast(size_t*)(_retArea.ptr + (24+4*size_t.sizeof))); + auto _ptr6 = _len6 ? cast(BoundingBox*)(*(cast(void**)(_retArea.ptr + (24+3*size_t.sizeof)))) : null; + auto _list7 = WitList!(BoundingBox)(_ptr6[0.._len6]); + auto _len8 = *(cast(size_t*)(_retArea.ptr + (24+6*size_t.sizeof))); + auto _ptr8 = _len8 ? cast(BoundingBox*)(*(cast(void**)(_retArea.ptr + (24+5*size_t.sizeof)))) : null; + auto _list9 = WitList!(BoundingBox)(_ptr8[0.._len8]); + auto _listSrcPtr16 = *(cast(void**)(_retArea.ptr + (32+8*size_t.sizeof))); + auto _listLen16 = *(cast(size_t*)(_retArea.ptr + (32+9*size_t.sizeof))); + auto _list16 = _listLen16 ? wit.common.mallocSlice!(Tuple!(WitString, WitString))(_listLen16) : []; + assert(!_listLen16 || _list16.ptr); + foreach (_elem10_idx, ref _elem10; _list16) { + const auto _base10 = _listSrcPtr16 + _elem10_idx * (4*size_t.sizeof); + auto _len11 = *(cast(size_t*)(_base10 + size_t.sizeof)); + auto _ptr11 = _len11 ? cast(char*)(*(cast(void**)(_base10 + 0))) : null; + auto _list12 = WitString(_ptr11[0.._len11]); + auto _len13 = *(cast(size_t*)(_base10 + (3*size_t.sizeof))); + auto _ptr13 = _len13 ? cast(char*)(*(cast(void**)(_base10 + (2*size_t.sizeof)))) : null; + auto _list14 = WitString(_ptr13[0.._len13]); + auto _tuple15 = Tuple!(WitString, WitString)( + _list12, + _list14, + ); + _elem10 = _tuple15; + } + if (_listLen16) wit.common.free(_listSrcPtr16); + auto _witList17 = WitList!(Tuple!(WitString, WitString))(_list16); + BlockState _record18 = { + id: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + 0)))), + blockId: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + 2)))), + blockName: _list5, + luminance: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (3*size_t.sizeof))))), + opacity: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (1+3*size_t.sizeof))))), + hardness: *(cast(float*)(_retArea.ptr + (4+3*size_t.sizeof))), + isAir: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (8+3*size_t.sizeof))))) != 0, + isLiquid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (9+3*size_t.sizeof))))) != 0, + isSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (10+3*size_t.sizeof))))) != 0, + isFullCube: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (11+3*size_t.sizeof))))) != 0, + pistonBehavior: cast(PistonBehavior)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (12+3*size_t.sizeof))))), + hasRandomTicks: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (13+3*size_t.sizeof))))) != 0, + burnable: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (14+3*size_t.sizeof))))) != 0, + toolRequired: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (15+3*size_t.sizeof))))) != 0, + sidedTransparency: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (16+3*size_t.sizeof))))) != 0, + replaceable: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (17+3*size_t.sizeof))))) != 0, + isSolidBlock: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (18+3*size_t.sizeof))))) != 0, + blockEntityType: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + (20+3*size_t.sizeof))))), + instrument: cast(NoteblockInstrument)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (22+3*size_t.sizeof))))), + collisionShapes: _list7, + outlineShapes: _list9, + downSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (24+7*size_t.sizeof))))) != 0, + upSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (25+7*size_t.sizeof))))) != 0, + northSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (26+7*size_t.sizeof))))) != 0, + southSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (27+7*size_t.sizeof))))) != 0, + westSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (28+7*size_t.sizeof))))) != 0, + eastSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (29+7*size_t.sizeof))))) != 0, + downCenterSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (30+7*size_t.sizeof))))) != 0, + upCenterSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (31+7*size_t.sizeof))))) != 0, + mapColor: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (32+7*size_t.sizeof))))), + properties: _witList17, + }; + auto _flush19 = _record18; + return _flush19; +} +/// ditto +@wasmImport!("pumpkin:plugin/world@0.1.0", "get-default-state-from-block") +pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__get_default_state_from_block") +private extern(C) void __import_getDefaultStateFromBlock(void*, void*) nothrow; + +/++ +Gets the default block state for a numerical block ID. ++/ +Option!(BlockState) getDefaultStateFromBlockId(ushort blockId) @trusted nothrow { + align(size_t.sizeof) void[(32+11*size_t.sizeof)] _retArea = void; + __import_getDefaultStateFromBlockId(cast(uint)(blockId), _retArea.ptr); + Option!(BlockState) _option17 = void; + bool _isSome17 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome17) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (3*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + (2*size_t.sizeof)))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + auto _len4 = *(cast(size_t*)(_retArea.ptr + (24+5*size_t.sizeof))); + auto _ptr4 = _len4 ? cast(BoundingBox*)(*(cast(void**)(_retArea.ptr + (24+4*size_t.sizeof)))) : null; + auto _list5 = WitList!(BoundingBox)(_ptr4[0.._len4]); + auto _len6 = *(cast(size_t*)(_retArea.ptr + (24+7*size_t.sizeof))); + auto _ptr6 = _len6 ? cast(BoundingBox*)(*(cast(void**)(_retArea.ptr + (24+6*size_t.sizeof)))) : null; + auto _list7 = WitList!(BoundingBox)(_ptr6[0.._len6]); + auto _listSrcPtr14 = *(cast(void**)(_retArea.ptr + (32+9*size_t.sizeof))); + auto _listLen14 = *(cast(size_t*)(_retArea.ptr + (32+10*size_t.sizeof))); + auto _list14 = _listLen14 ? wit.common.mallocSlice!(Tuple!(WitString, WitString))(_listLen14) : []; + assert(!_listLen14 || _list14.ptr); + foreach (_elem8_idx, ref _elem8; _list14) { + const auto _base8 = _listSrcPtr14 + _elem8_idx * (4*size_t.sizeof); + auto _len9 = *(cast(size_t*)(_base8 + size_t.sizeof)); + auto _ptr9 = _len9 ? cast(char*)(*(cast(void**)(_base8 + 0))) : null; + auto _list10 = WitString(_ptr9[0.._len9]); + auto _len11 = *(cast(size_t*)(_base8 + (3*size_t.sizeof))); + auto _ptr11 = _len11 ? cast(char*)(*(cast(void**)(_base8 + (2*size_t.sizeof)))) : null; + auto _list12 = WitString(_ptr11[0.._len11]); + auto _tuple13 = Tuple!(WitString, WitString)( + _list10, + _list12, + ); + _elem8 = _tuple13; + } + if (_listLen14) wit.common.free(_listSrcPtr14); + auto _witList15 = WitList!(Tuple!(WitString, WitString))(_list14); + BlockState _record16 = { + id: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + size_t.sizeof)))), + blockId: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + (2+1*size_t.sizeof))))), + blockName: _list3, + luminance: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (4*size_t.sizeof))))), + opacity: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (1+4*size_t.sizeof))))), + hardness: *(cast(float*)(_retArea.ptr + (4+4*size_t.sizeof))), + isAir: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (8+4*size_t.sizeof))))) != 0, + isLiquid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (9+4*size_t.sizeof))))) != 0, + isSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (10+4*size_t.sizeof))))) != 0, + isFullCube: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (11+4*size_t.sizeof))))) != 0, + pistonBehavior: cast(PistonBehavior)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (12+4*size_t.sizeof))))), + hasRandomTicks: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (13+4*size_t.sizeof))))) != 0, + burnable: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (14+4*size_t.sizeof))))) != 0, + toolRequired: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (15+4*size_t.sizeof))))) != 0, + sidedTransparency: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (16+4*size_t.sizeof))))) != 0, + replaceable: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (17+4*size_t.sizeof))))) != 0, + isSolidBlock: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (18+4*size_t.sizeof))))) != 0, + blockEntityType: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + (20+4*size_t.sizeof))))), + instrument: cast(NoteblockInstrument)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (22+4*size_t.sizeof))))), + collisionShapes: _list5, + outlineShapes: _list7, + downSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (24+8*size_t.sizeof))))) != 0, + upSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (25+8*size_t.sizeof))))) != 0, + northSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (26+8*size_t.sizeof))))) != 0, + southSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (27+8*size_t.sizeof))))) != 0, + westSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (28+8*size_t.sizeof))))) != 0, + eastSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (29+8*size_t.sizeof))))) != 0, + downCenterSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (30+8*size_t.sizeof))))) != 0, + upCenterSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (31+8*size_t.sizeof))))) != 0, + mapColor: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (32+8*size_t.sizeof))))), + properties: _witList15, + }; + + _option17 = Option!(BlockState).makeSome(_record16); + } else { + _option17 = Option!(BlockState).makeNone; + } + auto _flush18 = _option17; + return _flush18; +} +/// ditto +@wasmImport!("pumpkin:plugin/world@0.1.0", "get-default-state-from-block-id") +pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__get_default_state_from_block_id") +private extern(C) void __import_getDefaultStateFromBlockId(uint, void*) nothrow; + +/++ +Gets the detailed block state for a numerical block state ID. ++/ +Option!(BlockState) getBlockStateById(ushort stateId) @trusted nothrow { + align(size_t.sizeof) void[(32+11*size_t.sizeof)] _retArea = void; + __import_getBlockStateById(cast(uint)(stateId), _retArea.ptr); + Option!(BlockState) _option17 = void; + bool _isSome17 = (cast(uint)(*(cast(ubyte*)(_retArea.ptr + 0)))) != 0; + if (_isSome17) { + auto _len2 = *(cast(size_t*)(_retArea.ptr + (3*size_t.sizeof))); + auto _ptr2 = _len2 ? cast(char*)(*(cast(void**)(_retArea.ptr + (2*size_t.sizeof)))) : null; + auto _list3 = WitString(_ptr2[0.._len2]); + auto _len4 = *(cast(size_t*)(_retArea.ptr + (24+5*size_t.sizeof))); + auto _ptr4 = _len4 ? cast(BoundingBox*)(*(cast(void**)(_retArea.ptr + (24+4*size_t.sizeof)))) : null; + auto _list5 = WitList!(BoundingBox)(_ptr4[0.._len4]); + auto _len6 = *(cast(size_t*)(_retArea.ptr + (24+7*size_t.sizeof))); + auto _ptr6 = _len6 ? cast(BoundingBox*)(*(cast(void**)(_retArea.ptr + (24+6*size_t.sizeof)))) : null; + auto _list7 = WitList!(BoundingBox)(_ptr6[0.._len6]); + auto _listSrcPtr14 = *(cast(void**)(_retArea.ptr + (32+9*size_t.sizeof))); + auto _listLen14 = *(cast(size_t*)(_retArea.ptr + (32+10*size_t.sizeof))); + auto _list14 = _listLen14 ? wit.common.mallocSlice!(Tuple!(WitString, WitString))(_listLen14) : []; + assert(!_listLen14 || _list14.ptr); + foreach (_elem8_idx, ref _elem8; _list14) { + const auto _base8 = _listSrcPtr14 + _elem8_idx * (4*size_t.sizeof); + auto _len9 = *(cast(size_t*)(_base8 + size_t.sizeof)); + auto _ptr9 = _len9 ? cast(char*)(*(cast(void**)(_base8 + 0))) : null; + auto _list10 = WitString(_ptr9[0.._len9]); + auto _len11 = *(cast(size_t*)(_base8 + (3*size_t.sizeof))); + auto _ptr11 = _len11 ? cast(char*)(*(cast(void**)(_base8 + (2*size_t.sizeof)))) : null; + auto _list12 = WitString(_ptr11[0.._len11]); + auto _tuple13 = Tuple!(WitString, WitString)( + _list10, + _list12, + ); + _elem8 = _tuple13; + } + if (_listLen14) wit.common.free(_listSrcPtr14); + auto _witList15 = WitList!(Tuple!(WitString, WitString))(_list14); + BlockState _record16 = { + id: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + size_t.sizeof)))), + blockId: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + (2+1*size_t.sizeof))))), + blockName: _list3, + luminance: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (4*size_t.sizeof))))), + opacity: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (1+4*size_t.sizeof))))), + hardness: *(cast(float*)(_retArea.ptr + (4+4*size_t.sizeof))), + isAir: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (8+4*size_t.sizeof))))) != 0, + isLiquid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (9+4*size_t.sizeof))))) != 0, + isSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (10+4*size_t.sizeof))))) != 0, + isFullCube: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (11+4*size_t.sizeof))))) != 0, + pistonBehavior: cast(PistonBehavior)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (12+4*size_t.sizeof))))), + hasRandomTicks: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (13+4*size_t.sizeof))))) != 0, + burnable: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (14+4*size_t.sizeof))))) != 0, + toolRequired: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (15+4*size_t.sizeof))))) != 0, + sidedTransparency: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (16+4*size_t.sizeof))))) != 0, + replaceable: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (17+4*size_t.sizeof))))) != 0, + isSolidBlock: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (18+4*size_t.sizeof))))) != 0, + blockEntityType: cast(ushort)(cast(uint)(*(cast(ushort*)(_retArea.ptr + (20+4*size_t.sizeof))))), + instrument: cast(NoteblockInstrument)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (22+4*size_t.sizeof))))), + collisionShapes: _list5, + outlineShapes: _list7, + downSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (24+8*size_t.sizeof))))) != 0, + upSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (25+8*size_t.sizeof))))) != 0, + northSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (26+8*size_t.sizeof))))) != 0, + southSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (27+8*size_t.sizeof))))) != 0, + westSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (28+8*size_t.sizeof))))) != 0, + eastSideSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (29+8*size_t.sizeof))))) != 0, + downCenterSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (30+8*size_t.sizeof))))) != 0, + upCenterSolid: (cast(uint)(*(cast(ubyte*)(_retArea.ptr + (31+8*size_t.sizeof))))) != 0, + mapColor: cast(ubyte)(cast(uint)(*(cast(ubyte*)(_retArea.ptr + (32+8*size_t.sizeof))))), + properties: _witList15, + }; + + _option17 = Option!(BlockState).makeSome(_record16); + } else { + _option17 = Option!(BlockState).makeNone; + } + auto _flush18 = _option17; + return _flush18; +} +/// ditto +@wasmImport!("pumpkin:plugin/world@0.1.0", "get-block-state-by-id") +pragma(mangle, "__wit_import_pumpkin:plugin__world@0.1.0__get_block_state_by_id") +private extern(C) void __import_getBlockStateById(uint, void*) nothrow;